o NZh@sdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZddlmZmZdd lmZdd lmZdd lmZdd lmZmZmZmZd 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 dl/m0Z0m1Z1ddl2m2Z3ddl4m4Z5ddl6m6Z7ddl8m8Z9ddl:m:Z;ddlm?Z?d dl@mAZAede'dZBeCeDZEGdd d eZFd!ZGd"ZHGd#d$d$e!ZIGd%d&d&eZJGd'd(d(ZKGd)d*d*eKZLGd+d,d,ZMdmd1d2ZNdnd6d7ZOdod>d?ZPd@dAZQdpdEdFZRdpdGdHZSdqdKdLZTdrdNdOZUdsdQdRZVdtdUdVZWdudWdXZXdvd]d^ZYdwd`daZZGdbdcdce&j[Z\ddZ]dxdidjZ^Gdkdldle%j_Z`dS)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)Zsee_docs)r-LENIENTupper __members__r OptionErrorr emit)clsr1_moder<P/var/www/auris/lib/python3.10/site-packages/setuptools/command/editable_wheel.pyconvert@s z_EditableMode.convertN)r1r2r3r-) __name__ __module__ __qualname____doc__STRICTr5r4 classmethodr>r<r<r<r=r-4sr-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/d0Zdr1rC _empty_dir _LinkTreerR_find_packages_simple_layoutrVr4setrp _StaticPth_TopLevelFinder) rNrbrr~Z build_namerLr1 auxiliary_dirpackagesZhas_simple_layoutZis_compat_modesrc_dirr<r<r=rks      zeditable_wheel._select_strategyr3rP)r3r2)rbrkr}rr~rrr)r3r) rrkr}rr~rrrr3r)rrk)rrk)rbrkrrkr~rr3r)r?r@rArB descriptionrr-Z user_optionsrOrYrfr]rur|rrrrrrr`rrr<r<r<r=rEgs,   ?    rEc@s*eZdZdd d Zdd d ZdddZdS)rrr*r list[str]rMapping[str, str]r3objectcCdSrIr<rNrrrr<r<r=__call__szEditableStrategy.__call__r(cCrrIr<rMr<r<r= __enter__szEditableStrategy.__enter__ _exc_typetype[BaseException] | None _exc_valueBaseException | None _tracebackTracebackType | NonecCrrIr<rNrrrr<r<r=__exit__szEditableStrategy.__exit__N)rr*rrrrr3rr3r()rrrrrrr3r)r?r@rArrrr<r<r<r=rs  rc@s4eZdZdd d ZdddZdddZd ddZdS)!rrQrrbrk path_entries list[Path]r3rPcCs||_||_||_dSrI)rQrbr)rNrQrbrr<r<r=__init__s z_StaticPth.__init__rr*rrrrcCs>ddd|jD}t|d}|d|jd|dS)N css|] }t|VqdSrI)rkrq).0pr<r<r= z&_StaticPth.__call__..r.pth)rXr _encode_pthwritestrrb)rNrrrentriescontentsr<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 )listrwrTfspathrrwarning_LENIENT_WARNINGrNmsgr<r<r=rs z_StaticPth.__enter__rrrrcCrrIr<rr<r<r=rsz_StaticPth.__exit__N)rQrrbrkrrr3rPrr*rrrrrrrrrrrr3rP)r?r@rArrrrr<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. rQrrbrkrrr~r3rPcs>t||_t||_|dj|_t|||jgdS)Nr#) r rrqr~r copy_file_filesuperr)rNrQrbrr~ __class__r<r=rs z_LinkTree.__init__rr*rrrrcs |||t|||dSrI) _create_linksrrrrr<r=rs z_LinkTree.__call__filer2cCsRttt||j}t|tj dWdS1s"wYdS)N/) r ValueErrorr rq relative_tor~rkreplacerTsep)rNrrWr<r<r=_normalize_outputs  z_LinkTree._normalize_outputNrelative_outputsrc_filecCs6|j|}|js|jjdd|j|||ddS)NT)parentslink)rrvis_dirr\r)rNrrrdestr<r<r= _create_files  z_LinkTree._create_fileoutput_mappingc sjjdddtjrdnd}fdd|D}dd|D}|D]}|}|r8||vr8||q%|D] \}}j|||d q=dS) NT)rrZsymZhardc3s"|] \}}||fVqdSrI)rrkvrMr<r=rs z*_LinkTree._create_links..cSsi|] \}}|dur||qSrIr<rr<r<r= sz+_LinkTree._create_links..r)rr\_can_symlink_filesitemsrr) rNoutputsrZ link_typeZ normalisedZmappingsoutputZrelativesrcr<rMr=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.)rrr9rNrrrrr<r<r=rsz_LinkTree.__exit__) rQrrbrkrrr~rr3rPr)rrkr3r2rI)rrkrrk)rrrr) r?r@rArBrrrrrrr __classcell__r<r<rr=rs     rc@sHeZdZd!ddZd"d d Zd#d dZd$ddZd%ddZd&ddZd S)'rrQrrbrkr3rPcCs||_||_dSrI)rQrb)rNrQrbr<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|]}|gfVqdSrIr<)rnsr<r<r=r sz0_TopLevelFinder.template_vars..cs"i|] }|t|jjp dqS)rH)rrQrSrpkgrootsrNr<r=r sz1_TopLevelFinder.template_vars..rz.finder)rQrSrTrUr r_find_top_level_modulesrV_find_package_rootsdict_find_namespacesr_find_virtual_namespacesrorbrZsafe_identifier) rNrSZ top_levelrV namespaces_Zlegacy_namespacesrrbfinderr<rr= 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)rbytes_finder_templaterrb)rNrrbrrcontentr<r<r=get_implementations z"_TopLevelFinder.get_implementationrr*rrrrcCs"|D] \}}|||qdSrI)r%r)rNrrrrr$r<r<r=r$sz_TopLevelFinder.__call__r(cCr )Nz=Editable install will be performed using a meta path finder. )rrrrr<r<r=r(rz_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. r)rr9rr<r<r=r-sz_TopLevelFinder.__exit__N)rQrrbrkr3rP)r3r)r3r rrr) r?r@rArrr%rrrr<r<r<r=rs    rr$rkr3r"cCs`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 TextIOWrapperrZ PTH_ENCODINGwriteflushseekread)r$bufferwrapperr<r<r=r:s   $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.txtZfile1r!r&TzFile system does not seem to support either symlinks or hard links. Strict editable installs require one of them to be supported.F)r rkrqr write_textrAttributeErrorNotImplementedErrorOSErrorrTsymlink is_symlink read_textrraLinksNotSupported)r1rZpath1Zpath2rdrr<r<r=rOs*   $rr Iterable[str]rVdict[str, str]rLrcsZfdd|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<rr)rVrLr<r=rsz"_simple_layout..rHc3s2|]\}}ttg|dR|VqdSrnN)rZ same_pathr split)rkeyvalue)rvr<r=rs  z!_simple_layout..)rrTrW commonpathr _parent_pathrall)rrVrLZlayoutr<)rVrvrLr=rcs rcCs0||r|dt| n|}|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' Nr)rllenrstriprTr)rpkg_pathrvr<r<r=rCs rCrQr Iterator[str]ccs~t|jpgEdH|jpg}dd|D}|jr|jVn|jp#g}|dd|D7}|D] }|d\}}}|Vq/dS)NcSsg|]}d|vr|qSrnr<rmodr<r<r= sz"_find_packages..cSsg|] }d|jvr|jqSrIrbrxr<r<r=rLsrn)iterr py_modules ext_package ext_modules rpartition)rQrQZnested_modulesrSmodulepackage_r<r<r=rs   rccsL|jpg}dd|DEdH|js$|jpg}dd|DEdHdSdS)Ncss|] }d|vr|VqdSr>r<rJr<r<r=rrz*_find_top_level_modules..css |] }d|jvr|jVqdSr>rMrNr<r<r=rs)rQrRrS)rQrQrSr<r<r=rs  rrrScs fddt|D}t|S)Ncsi|] }|tt|qSr<)_absolute_rootrrrVrSr<r=rsz'_find_package_roots..)sorted_remove_nested)rrVrS pkg_rootsr<rYr=rs rrWcCs4t|}|j}|rt|St||jS)z(Works for packages and top-level modules)r rvrmrkrqrb)rWZpath_rvr<r<r=rXs  rXr\ccsv|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. rnr!rNrH)r?rangerErXr rrm)r\rpartsiZ partial_namerWr<r<r=rs  rrIterator[tuple[str, list[str]]]ccsB|D]}t||d}t|rt|ds||gfVqdS)NrHz __init__.py)rr rm)rr\rrWr<r<r=rs  rcsPt|}tt|D]\tfdd|Dr%|q|S)Nc3s*|]\}}|kot||VqdSrI) _is_nested)rother other_pathrWrr<r=rs  z!_remove_nested..)rcopyreversedrranypop)r\r r<rer=r[s  r[rrGrv 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 rHr!rn)rnormpathrstripr? startswithr )rrGrvrjZ norm_pkg_pathrestr<r<r=rbs rbdir_cCstj|ddt||S)zFCreate a directory ensured to be empty. Existing files may be removed.T) ignore_errors)rrmtreerTmakedirs)ror<r<r=rs rc@s&eZdZd ddZddZddZd S) rrr3rPcCs(||_||_||_||_g|_d|_dS)NF)rRrSrs editable_namer dry_run)rNrRrsrsrSr<r<r=rs  z_NamespaceInstaller.__init__cCstj|j|j|jS)zInstallation target.)rTrWrXrsrsZ nspkg_extrMr<r<r=_get_nspkg_filesz#_NamespaceInstaller._get_nspkg_filecCstt|jS)z1Where the modules/packages should be loaded from.)reprrkrSrMr<r<r= _get_root#sz_NamespaceInstaller._get_rootNr)r?r@rArrurwr<r<r<r=rrs  rra 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 rbrrdict[str, list[str]]cCs(tt|ddd}tj|||dS)z_Create a string containing the code for the``MetaPathFinder`` and ``PathEntryFinder``. cSs|dS)Nrr<)rr<r<r=sz"_finder_template..)r@rbrr)rrZr_FINDER_TEMPLATEformatrzr<r<r=r#sr#c@seZdZdZdS)r;zCFile system does not seem to support either symlinks or hard links.N)r?r@rArBr<r<r<r=r;sr;)r$rkr3r")r1r r3r2)rr<rVr=rLrr3r2)rQrr3rH)rr<rVrrSrr3r=)rWrr3rk)r\r=r3rH)rrr\r=r3ra)r\r=r3r=) rrkrGrkrvrkrjrkr3r2)ror+r3r+)rbrkrrrrxr3rk)arB __future__rr(loggingrTrrcollections.abcrrr contextlibrenumrinspectr itertoolsr r pathlibr tempfiler typesr typingrrrrrHrrrrrrrr0rrZ discoveryrrQrwarningsrr r"rr#rr$rhr%rr&rr'rZtyping_extensionsr(Z_vendor.wheel.wheelfiler*r+ getLoggerr?rr-r rrErrrrrrrrCrrrrXrrr[rbrZ Installerrrr{r#Z FileErrorr;r<r<r<r=sx                     )! L ?  )     Y