o 5i.@sdZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZddlmZddlmZddlmZmZdd lmZdd lmZdd lmZdd lmZmZmZm Z d dl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'd dl$m(Z(d dl)m*Z*m+Z+d dl,m-Z-d dl.m/Z/d dl0m1Z1m2Z2ddl3m3Z4ddl5m5Z6ddl7m7Z8ddl9m9Z:ddl;m;Z<ddl=m=Z>erddl?m@Z@d dlAmBZBede(dZCeDeEZFGdd d eZGd!ZHd"ZIGd#d$d$e"ZJGd%d&d&eZKGd'd(d(ZLGd)d*d*eLZMGd+d,d,ZNdmd1d2ZOdnd6d7ZPdod>d?ZQd@dAZRdpdEdFZSdpdGdHZTdqdKdLZUdrdNdOZVdsdQdRZWdtdUdVZXdudWdXZYdvd]d^ZZdwd`daZ[Gdbdcdce'j\Z]ddZ^dxdidjZ_Gdkdldle&j`ZadS)ya Create a wheel that, when installed, will make the source package 'editable' (add it to the interpreter's path, including metadata) per PEP 660. Replaces 'setup.py develop'. .. note:: One of the mechanisms briefly mentioned in PEP 660 to implement editable installs is to create a separated directory inside ``build`` and use a .pth file to point to that directory. In the context of this file such directory is referred as *auxiliary build directory* or ``auxiliary_dir``. ) annotationsN)IterableIteratorMapping)suppress)Enum)cleandoc)chainstarmap)Path)TemporaryDirectory) TracebackType) TYPE_CHECKINGProtocolTypeVarcast)Command_normalization_path_shutilerrors namespaces)StrPath)py310py312find_package_path) Distribution)InformationOnlySetuptoolsDeprecationWarning)build)build_py) dist_info)egg_info)install)install_scripts)Self WheelFile_P)boundc@s*eZdZdZdZdZdZed dd Zd S) _EditableModea Possible editable installation modes: `lenient` (new files automatically added to the package - DEFAULT); `strict` (requires a new installation when files are added/removed); or `compat` (attempts to emulate `python setup.py develop` - DEPRECATED). strictlenientcompatmode str | NonereturncCsN|stjS|}|tjvrtd|d|dkr#tjddddt|S)NzInvalid editable mode: z. Try: 'strict'.COMPATzCompat editable installsa  The 'compat' editable mode is transitional and will be removed in future versions of `setuptools`. Please adapt your code accordingly to use either the 'strict' or the 'lenient' modes. zuserguide/development_mode.html)see_docs)r-LENIENTupper __members__r OptionErrorr emit)clsr1_moder=`/root/parts/websockify/install/lib/python3.10/site-packages/setuptools/command/editable_wheel.pyconvertAs z_EditableMode.convertN)r1r2r3r-) __name__ __module__ __qualname____doc__STRICTr6r4 classmethodr?r=r=r=r>r-5sr-zU New or renamed files may not be automatically picked up without a new installation. zt Options like `package-data`, `include/exclude-package-data` or `packages.find.exclude/include` may have no effect. c@seZdZdZdZddddeejpdfgZdd Zd5d d Z d5ddZ ddZ ddZ d6ddZ d7ddZdd Zd8d"d#Zd9d%d&Zd5d'd(Zd:d*d+Zd,d-Zd;d/d0Zdinitialize_optionsvs z!editable_wheel.initialize_optionsr3NonecCs@|j}|jptj|_|jpi|_t|jptj |jd|_dS)Ndist) distributionsrc_rootoscurdirrM package_dirr rKpathjoin)rOrRr=r=r>finalize_options|s  zeditable_wheel.finalize_optionsc Csz#|jjdd||d|d}||j||WdStyC}z|j j p3|j }t |d|dd}~ww)NT)exist_ok bdist_wheelz3An error occurred when building editable wheel for zl. See debugging tips in: https://setuptools.pypa.io/en/latest/userguide/development_mode.html#debugging-tips)rKmkdir_ensure_dist_inforeinitialize_commandget_finalized_commandwrite_wheelfilerL_create_wheel_file ExceptionrSnameget_nameradd_note)rOr\exprojectr=r=r>runs     zeditable_wheel.runcCsj|jdurtt|d}|j|_|||j|_dSt|j ds)Jt |jd s3JdS)Nr$z .dist-infoMETADATA) rLr dist_info_clsr_rK output_dirensure_finalizedristrendswithr exists)rOr$r=r=r>r^s  z editable_wheel._ensure_dist_infocCsD|j}|jsdSt|j|jdd}t||||}|dS)NrI.) rSnamespace_packagesr rMrWgetresolve_NamespaceInstallerinstall_namespaces)rOinstallation_dir pth_prefixrRrT installerr=r=r>_install_namespacess  z"editable_wheel._install_namespacesr2cCs2|jr t|jjnt}tt|d}t|dS)Nz *.egg-info)rLr parentmaprnglobnext)rO parent_dir candidatesr=r=r>_find_egg_info_dirs z!editable_wheel._find_egg_info_dirrdrnunpacked_wheelr build_libtmp_dircCsL|j}t|}t|}tt||dd}tt||dd}tt||dd} tt|jddd} t|| _d| _tt|jddd} tt |jd dd} || _ | _ | _ || _ | _| _| | _| _|| _|| _|d } d | _tt|d }d|_t|| _tt|d }d|_||_|| | dS)aConfigure commands to behave in the following ways: - Build commands can write to ``build_lib`` if they really want to... (but this folder is expected to be ignored and modules are expected to live in the project directory...) - Binary extensions should be built in-place (editable_mode = True) - Data/header/script files are not part of the "editable" specification so they are written directly to the unpacked_wheel directory. z.datadataheadersscriptsr%T)reinit_subcommandsr"r& build_scriptspythonr'r#FN)rSrnr r egg_info_clsr_egg_baseignore_egg_info_in_manifest build_cls install_cls build_platlib build_purelibrinstall_purelibinstall_platlib install_libr'rinstall_headers install_dataget_command_obj executableinstall_scripts_clsno_ep build_temp build_py_clscompilerexisting_egg_info_dir_set_editable_moderm)rOrdrrrrRwheelrrrr%r"r&rr'r#r=r=r>_configure_buildsF       zeditable_wheel._configure_buildcCsN|j}|d}|D]}||}t|drd|_q t|dr$d|_q dS)z8Set the ``editable_mode`` flag in the build sub-commandsr" editable_modeTinplaceN)rSrget_sub_commandshasattrrr)rOrRr"cmd_namecmdr=r=r>rs     z!editable_wheel._set_editable_mode tuple[list[str], dict[str, str]]cCsjg}i}|d}|D]#}||}t|dr"||p gt|dr0||p.iq ||fS)Nr" get_outputsget_output_mapping)r`rrextendrupdater)rOfilesmappingr"rrr=r=r>_collect_build_outputss     z%editable_wheel._collect_build_outputs dist_namecCsJ|||||||\}}|d|d|d||fS)Nrrr)r_run_build_subcommandsr _run_install)rOrrrrrrr=r=r>_run_build_commands s    z"editable_wheel._run_build_commandscCsP|d}|D]}||}|dkr t|tur ||q ||q dS)a} Issue #3501 indicates that some plugins/customizations might rely on: 1. ``build_py`` not running 2. ``build_py`` always copying files to ``build_lib`` However both these assumptions may be false in editable_wheel. This method implements a temporary workaround to support the ecosystem while the implementations catch up. r"r#N)r`rtyper _safely_run run_command)rOr"rdrr=r=r>rs     z%editable_wheel._run_build_subcommandsrc CsFz||WSty"tddtd|d|dYdSw)Nz0Customization incompatible with editable installz z If you are seeing this warning it is very likely that a setuptools plugin or customization overrides the `a` command, without taking into consideration how editable installs run build steps starting from setuptools v64.0.0. Plugin authors and developers relying on custom build steps are encouraged to update their `aa` implementation considering the information about editable installs in https://setuptools.pypa.io/en/latest/userguide/extension.html. For the time being `setuptools` will silence this error and ignore the faulty command, but this behavior will change in future versions. )rrcr r: traceback format_exc)rOrr=r=r>r.s    zeditable_wheel._safely_runc Csddlm}|d}|j}d|}d}|d|d|d}t|j|}|r0| t |d} t dd} t d d} | } | s} | a}t| t|j j}t |j ||| |||| | |\}}|||| }|(||d }|||||| Wdn1swYWdn1swYWdn1swYWdn1swYWd|SWd|S1swY|S) Nrr)r$-z 0.editablez.whl)suffixz .build-libz .build-tempw)wheel.wheelfiler*r`rdrYget_tagr rKrpunlinkr rLshutilcopytreerzr_select_strategy write_files)rOr\r*r$rtag build_tag archive_name wheel_pathrr build_tmpunpackedlibtmpunpacked_dist_inforrstrategy wheel_objr=r=r>rbJsB         (   z!editable_wheel._create_wheel_filecategorycCsLt|jd|d}|r"|r$td|d|d|dSdSdS)Nhas_z Installing z as non editableinstall_)getattrrS_loggerinfor)rOr has_categoryr=r=r>rfs  zeditable_wheel._run_installrEditableStrategyc Csd|d|}t|j}t|j}|tjur)tt|jd|}t|j|||St |j}t ||j |} |tj u} t |j dhkrD| sF| rX|j dd} t|j|t|| gSt|j|S)zDDecides which strategy to use to implement an editable installation. __editable__.rr"rIrq)r rMr-r?r1rD _empty_dir _LinkTreerS_find_packages_simple_layoutrWr4setrs _StaticPth_TopLevelFinder) rOrdrr build_namerMr1 auxiliary_dirpackageshas_simple_layoutis_compat_modesrc_dirr=r=r>rls      zeditable_wheel._select_strategyr3rQ)r3r2)rdrnrrrrrr)r3r) rrnrrrrrrr3r)rrn)rrn)rdrnrrnrrr3r)r@rArBrC descriptionrr- user_optionsrPrZrir^rzrrrrrrrrbrrr=r=r=r>rFhs,   ?    rFc@s*eZdZdd d Zdd d ZdddZdS)rrr*r list[str]rMapping[str, str]r3objectcCdSrJr=rOrrrr=r=r>__call__szEditableStrategy.__call__r(cCrrJr=rNr=r=r> __enter__szEditableStrategy.__enter__ _exc_typetype[BaseException] | None _exc_valueBaseException | None _tracebackTracebackType | NonecCrrJr=rOrrrr=r=r>__exit__szEditableStrategy.__exit__N)rr*rrrrr3rr3r()rrrrrrr3r)r@rArBrrrr=r=r=r>rs  rc@s4eZdZdd d ZdddZdddZd ddZdS)!rrRrrdrn path_entries list[Path]r3rQcCs||_||_||_dSrJ)rRrdr)rOrRrdrr=r=r>__init__s z_StaticPth.__init__rr*rrrrcCs>ddd|jD}t|d}|d|jd|dS)N css|] }t|VqdSrJ)rnrt).0pr=r=r> z&_StaticPth.__call__..r.pth)rYr _encode_pthwritestrrd)rOrrrentriescontentsr=r=r>rsz_StaticPth.__call__r(cCs,dtttj|jd}t|t|S)Nz_ Editable install will be performed using .pth file to extend `sys.path` with: z )listr|rUfspathrrwarning_LENIENT_WARNINGrOmsgr=r=r>rs z_StaticPth.__enter__rrrrcCrrJr=rr=r=r>rsz_StaticPth.__exit__N)rRrrdrnrrr3rQrr*rrrrr3rQrrrrrrrr3rQ)r@rArBrrrrr=r=r=r>rs    rcsdeZdZdZd*fd d Zd+fdd Zd,ddZd-d.ddZd/dd Zd0d"d#Z d1d(d)Z Z S)2ra` Creates a ``.pth`` file that points to a link tree in the ``auxiliary_dir``. This strategy will only link files (not dirs), so it can be implemented in any OS, even if that means using hardlinks instead of symlinks. By collocating ``auxiliary_dir`` and the original source code, limitations with hardlinks should be avoided. rRrrdrnrrrr3rQcs>t||_t||_|dj|_t|||jgdS)Nr#) r rrtrr copy_file_filesuperr)rOrRrdrr __class__r=r>rs z_LinkTree.__init__rr*rrrrcs |||t|||dSrJ) _create_linksrrrrr=r>rs z_LinkTree.__call__filer2cCsRttt||j}t|tj dWdS1s"wYdS)N/) r ValueErrorr rt relative_torrnreplacerUsep)rOrrXr=r=r>_normalize_outputs  z_LinkTree._normalize_outputNrelative_outputsrc_filecCs6|j|}|js|jjdd|j|||ddS)NT)parentslink)rr{is_dirr]r )rOrrrdestr=r=r> _create_files  z_LinkTree._create_fileoutput_mappingc sjjdddtjrdnd}fdd|D}dd|D}|D]}|}|r8||vr8||q%|D] \}}j|||d q=dS) NT)rr[symhardc3s"|] \}}||fVqdSrJ)rrkvrNr=r>rs z*_LinkTree._create_links..cSsi|] \}}|dur||qSrJr=r$r=r=r> sz+_LinkTree._create_links..r)rr]_can_symlink_filesitemsrr ) rOoutputsr! link_type normalisedmappingsoutputrelativesrcr=rNr>rs   z_LinkTree._create_linksr(cCd}t|t|S)Nz=Strict editable install will be performed using a link tree. )rr_STRICT_WARNINGrr=r=r>rz_LinkTree.__enter__rrrrcCsd|jd}td|dS)Nz\ Strict editable installation performed using the auxiliary directory: z Please be careful to not remove this directory, otherwise you might not be able to import/use your package. Editable installation.)rrr:rOrrrr r=r=r>rsz_LinkTree.__exit__) rRrrdrnrrrrr3rQr )rrnr3r2rJ)rrnrrn)r!rrr ) r@rArBrCrrrr rrr __classcell__r=r=rr>rs     rc@sHeZdZd!ddZd"d d Zd#d dZd$ddZd%ddZd&ddZd S)'rrRrrdrnr3rQcCs||_||_dSrJ)rRrd)rOrRrdr=r=r>rs z_TopLevelFinder.__init__5tuple[str, str, dict[str, str], dict[str, list[str]]]c sjjptj}ttjtj}jjpi}t|||t tt jj p&gddt D}fddjj p>gD}i|}djd}t|}||||fS)Ncss|]}|gfVqdSrJr=)rnsr=r=r>rsz0_TopLevelFinder.template_vars..cs"i|] }|t|jjp dqS)rI)rrRrTrpkgrootsrOr=r>r'sz1_TopLevelFinder.template_vars..rz.finder)rRrTrUrVr r_find_top_level_modulesrW_find_package_rootsdict_find_namespacesr_find_virtual_namespacesrrrdrsafe_identifier) rOrT top_levelrW namespaces_legacy_namespacesrrdfinderr=r;r> template_varss"       z_TopLevelFinder.template_varsIterator[tuple[str, bytes]]ccsb|\}}}}tt|||d}|d|fVtd|d|d}d|jd|fVdS)Nutf-8z.pyzimport z; z .install()rr)rGbytes_finder_templaterrd)rOrFrdrrDcontentr=r=r>get_implementation s z"_TopLevelFinder.get_implementationrr*rrrrcCs"|D] \}}|||qdSrJ)rMr)rOrrrrrLr=r=r>r)sz_TopLevelFinder.__call__r(cCr1)Nz=Editable install will be performed using a meta path finder. )rrrrr=r=r>r/r3z_TopLevelFinder.__enter__rrrrcCsd}td|dS)Nz Please be careful with folders in your working directory with the same name as your package as they may take precedence during imports. r4)rr:r5r=r=r>r4sz_TopLevelFinder.__exit__N)rRrrdrnr3rQ)r3r7)r3rHr rr ) r@rArBrrGrMrrrr=r=r=r>rs    rrLrnr3rJcCs`t"}tj|tjd}||||d|WdS1s)wYdS)a Prior to Python 3.13 (see https://github.com/python/cpython/issues/77102), .pth files are always read with 'locale' encoding, the recommendation from the cpython core developers is to write them as ``open(path, "w")`` and ignore warnings (see python/cpython#77102, pypa/setuptools#3937). This function tries to simulate this behavior without having to create an actual file, in a way that supports a range of active Python versions. (There seems to be some variety in the way different version of Python handle ``encoding=None``, not all of them use ``locale.getpreferredencoding(False)`` or ``locale.getencoding()``). encodingrN) ioBytesIO TextIOWrapperr PTH_ENCODINGwriteflushseekread)rLbufferwrapperr=r=r>rAs   $rbase_dirr boolc Cstt|do}t|dt|d}}|jdddtttt)t ||| rD|j dddkrD WdWddSWdn1sNwYzt ||Wntyn}zd}t||d}~ww Wdd S1s{wYdS) N)dirz file1.txtz file2.txtfile1rIrNTzFile system does not seem to support either symlinks or hard links. Strict editable installs require one of them to be supported.F)r rnrtr write_textrAttributeErrorNotImplementedErrorOSErrorrUsymlink is_symlink read_textrrcLinksNotSupported)rZrpath1path2rgr r=r=r>r(Vs*   $r(r Iterable[str]rWdict[str, str]rMrcsZfdd|D}|stidhfvStjtt|tfdd|DS)a[Return ``True`` if: - all packages are contained by the same parent directory, **and** - all packages become importable if the parent directory is added to ``sys.path``. >>> _simple_layout(['a'], {"": "src"}, "/tmp/myproj") True >>> _simple_layout(['a', 'a.b'], {"": "src"}, "/tmp/myproj") True >>> _simple_layout(['a', 'a.b'], {}, "/tmp/myproj") True >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"": "src"}, "/tmp/myproj") True >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "a", "b": "b"}, ".") True >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a", "b": "_b"}, ".") False >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a"}, "/tmp/myproj") False >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a.a1.a2": "_a2"}, ".") False >>> _simple_layout(['a', 'a.b'], {"": "src", "a.b": "_ab"}, "/tmp/myproj") False >>> # Special cases, no packages yet: >>> _simple_layout([], {"": "src"}, "/tmp/myproj") True >>> _simple_layout([], {"a": "_a", "": "src"}, "/tmp/myproj") False csi|] }|t|qSr=rr9)rWrMr=r>r'sz"_simple_layout..rIc3s2|]\}}ttg|dR|VqdSrqN)r same_pathr split)rkeyvalue)r{r=r>rs  z!_simple_layout..)rrUrX commonpathr _parent_pathr)all)rrWrMlayoutr=)rWr{rMr>rjs rcCs||}|dtjS)a7Infer the parent path containing a package, that if added to ``sys.path`` would allow importing that package. When ``pkg`` is directly mapped into a directory with a different name, return its own path. >>> _parent_path("a", "src/a") 'src' >>> _parent_path("b", "src/c") 'src/c' r) removesuffixrstriprUr)r:pkg_pathr{r=r=r>rps rprRr Iterator[str]ccs~t|jpgEdH|jpg}dd|D}|jr|jVn|jp#g}|dd|D7}|D] }|d\}}}|Vq/dS)NcSsg|]}d|vr|qSrqr=rmodr=r=r> sz"_find_packages..cSsg|] }d|jvr|jqSrwrdrxr=r=r>rzsrq)iterr py_modules ext_package ext_modules rpartition)rRrnested_modulesrmodulepackage_r=r=r>rs   rccsL|jpg}dd|DEdH|js$|jpg}dd|DEdHdSdS)Ncss|] }d|vr|VqdSrjr=rxr=r=r>rrz*_find_top_level_modules..css |] }d|jvr|jVqdSrjr{r|r=r=r>rs)rrr)rRrrr=r=r>r=s  r=rrTcs fddt|D}t|S)Ncsi|] }|tt|qSr=)_absolute_rootrr9rWrTr=r>r'sz'_find_package_roots..)sorted_remove_nested)rrWrT pkg_rootsr=rr>r>s r>rXcCs4t|}|j}|rt|St||jS)z(Works for packages and top-level modules)r r{rprnrtrd)rXpath_r{r=r=r>rs  rrccsv|D]5}d|vr q|d}tt|dddD]}d|d|}tt||d}|r4||vr7|VqqdS)a8By carefully designing ``package_dir``, it is possible to implement the logical structure of PEP 420 in a package without the corresponding directories. Moreover a parent package can be purposefully/accidentally skipped in the discovery phase (e.g. ``find_packages(include=["mypkg.*"])``, when ``mypkg.foo`` is included by ``mypkg`` itself is not). We consider this case to also be a virtual namespace (ignoring the original directory) to emulate a non-editable installation. This function will try to find these kinds of namespaces. rqr!rNrI)rlrangelenrYr rrp)rr:partsi partial_namerXr=r=r>rAs  rArIterator[tuple[str, list[str]]]ccsB|D]}t||d}t|rt|ds||gfVqdS)NrIz __init__.py)rr rp)rrr:rXr=r=r>r@s  r@csPt|}tt|D]\tfdd|Dr%|q|S)Nc3s*|]\}}|kot||VqdSrJ) _is_nested)rother other_pathrXr:r=r>rs  z!_remove_nested..)r?copyreversedrr)anypop)rr.r=rr>rs  rr:rur{ parent_pathcCsHt|}||dddd}||o#|tt|g|RkS)a Return ``True`` if ``pkg`` is nested inside ``parent`` both logically and in the file system. >>> _is_nested("a.b", "path/a/b", "a", "path/a") True >>> _is_nested("a.b", "path/a/b", "a", "otherpath/a") False >>> _is_nested("a.b", "path/a/b", "c", "path/c") False >>> _is_nested("a.a", "path/a/a", "a", "path/a") True >>> _is_nested("b.a", "path/b/a", "a", "path/a") False rIr!rq)rnormpathrstriprl startswithr )r:rur{r norm_pkg_pathrestr=r=r>rs rdir_cCstj|ddt||S)zFCreate a directory ensured to be empty. Existing files may be removed.T) ignore_errors)rrmtreerUmakedirs)rr=r=r>rs rc@s&eZdZd ddZddZddZd S) rur3rQcCs"||_||_||_||_g|_dSrJ)rSrTrw editable_namer*)rOrSrwrrTr=r=r>rs  z_NamespaceInstaller.__init__cCstj|j|j|jS)zInstallation target.)rUrXrYrwr nspkg_extrNr=r=r>_get_nspkg_file%sz#_NamespaceInstaller._get_nspkg_filecCstt|jS)z1Where the modules/packages should be loaded from.)reprrnrTrNr=r=r> _get_root)sz_NamespaceInstaller._get_rootNr)r@rArBrrrr=r=r=r>rus  rua from __future__ import annotations import sys from importlib.machinery import ModuleSpec, PathFinder from importlib.machinery import all_suffixes as module_suffixes from importlib.util import spec_from_file_location from itertools import chain from pathlib import Path MAPPING: dict[str, str] = {mapping!r} NAMESPACES: dict[str, list[str]] = {namespaces!r} PATH_PLACEHOLDER = {name!r} + ".__path_hook__" class _EditableFinder: # MetaPathFinder @classmethod def find_spec(cls, fullname: str, path=None, target=None) -> ModuleSpec | None: # type: ignore # Top-level packages and modules (we know these exist in the FS) if fullname in MAPPING: pkg_path = MAPPING[fullname] return cls._find_spec(fullname, Path(pkg_path)) # Handle immediate children modules (required for namespaces to work) # To avoid problems with case sensitivity in the file system we delegate # to the importlib.machinery implementation. parent, _, child = fullname.rpartition(".") if parent and parent in MAPPING: return PathFinder.find_spec(fullname, path=[MAPPING[parent]]) # Other levels of nesting should be handled automatically by importlib # using the parent path. return None @classmethod def _find_spec(cls, fullname: str, candidate_path: Path) -> ModuleSpec | None: init = candidate_path / "__init__.py" candidates = (candidate_path.with_suffix(x) for x in module_suffixes()) for candidate in chain([init], candidates): if candidate.exists(): return spec_from_file_location(fullname, candidate) return None class _EditableNamespaceFinder: # PathEntryFinder @classmethod def _path_hook(cls, path) -> type[_EditableNamespaceFinder]: if path == PATH_PLACEHOLDER: return cls raise ImportError @classmethod def _paths(cls, fullname: str) -> list[str]: paths = NAMESPACES[fullname] if not paths and fullname in MAPPING: paths = [MAPPING[fullname]] # Always add placeholder, for 2 reasons: # 1. __path__ cannot be empty for the spec to be considered namespace. # 2. In the case of nested namespaces, we need to force # import machinery to query _EditableNamespaceFinder again. return [*paths, PATH_PLACEHOLDER] @classmethod def find_spec(cls, fullname: str, target=None) -> ModuleSpec | None: # type: ignore if fullname in NAMESPACES: spec = ModuleSpec(fullname, None, is_package=True) spec.submodule_search_locations = cls._paths(fullname) return spec return None @classmethod def find_module(cls, _fullname) -> None: return None def install(): if not any(finder == _EditableFinder for finder in sys.meta_path): sys.meta_path.append(_EditableFinder) if not NAMESPACES: return if not any(hook == _EditableNamespaceFinder._path_hook for hook in sys.path_hooks): # PathEntryFinder is needed to create NamespaceSpec without private APIS sys.path_hooks.append(_EditableNamespaceFinder._path_hook) if PATH_PLACEHOLDER not in sys.path: sys.path.append(PATH_PLACEHOLDER) # Used just to trigger the path hook rdrrdict[str, list[str]]cCs*tt|tdd}tj|||dS)z_Create a string containing the code for the``MetaPathFinder`` and ``PathEntryFinder``. r)rmrdrr)r?rr)operator itemgetter_FINDER_TEMPLATEformatrr=r=r>rKsrKc@seZdZdZdS)rezCFile system does not seem to support either symlinks or hard links.N)r@rArBrCr=r=r=r>resre)rLrnr3rJ)rZr r3r[)rrhrWrirMrr3r[)rRrr3rv)rrhrWrrTrr3ri)rXrr3rn)rrir3rv)rrrrir3r)rrir3ri) r:rnrurnr{rnrrnr3r[)rr+r3r+)rdrnrrrrr3rn)brC __future__rrPloggingrrUrrcollections.abcrrr contextlibrenumrinspectr itertoolsr r pathlibr tempfiler typesr typingrrrrrIrrrrrrrr0rr discoveryrrRrwarningsrr r"rr#rr$rkr%rr&rr'rtyping_extensionsr(_vendor.wheel.wheelfiler*r+ getLoggerr@rr-r2rrFrrrrrr(rrprr=r>rrAr@rrr InstallerrurrK FileErrorrer=r=r=r>sz                     )! N A  )     Y