ruạṛ
a �u:jK� � @ s d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZ ddlmZ ddlmZ ddlmZmZ dd lmZ dd lmZ dd lmZ dd l m Z m Z m Z m 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 dl0m1Z1m2Z2 ddl3m3Z4 ddl5m5Z6 ddl7m7Z8 ddl9m9Z: ddl;m;Z< ddl=m=Z> e �r�ddl?m@Z@ d d lAmBZB e d e(d �ZCe�DeE�ZFG d d � d e�ZGd!ZHd"ZIG d#d$� d$e"�ZJG d%d&� d&e �ZKG d'd(� d(�ZLG d)d*� d*eL�ZMG d+d,� d,�ZNd-d.d/�d0d1�ZOd2d3d4�d5d6�ZPd7d8d9d3d:�d;d<�ZQd=d>� ZRd?d@dA�dBdC�ZSd?d@dA�dDdE�ZTd7dFd9d8dG�dHdI�ZUd9d-dJ�dKdL�ZVd8d@dM�dNdO�ZWdPd8dQdR�dSdT�ZXd8d8dM�dUdV�ZYd-d-d-d-d3dW�dXdY�ZZd d dZ�d[d\�Z[G d]d^� d^e'j\�Z]d_Z^d-dFd`d-da�dbdc�Z_G ddde� dee&j`�ZadS )fa� 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)�Iterable�Iterator�Mapping)�suppress)�Enum)�cleandoc)�chain�starmap)�Path)�TemporaryDirectory)� TracebackType)� TYPE_CHECKING�Protocol�TypeVar�cast� )�Command�_normalization�_path�_shutil�errors� namespaces)�StrPath)�py310�py312��find_package_path)� Distribution)�InformationOnly� SetuptoolsDeprecationWarning� )�build)�build_py)� dist_info)�egg_info)�install)�install_scripts)�Self�� WheelFile�_P)�boundc @ s0 e Zd ZdZdZdZdZedd d�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). �strict�lenient�compat� str | None)�mode�returnc C sN |s t jS |�� }|t jvr.t�d|�d���|dkrFtjdddd� t | 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. z userguide/development_mode.html)Zsee_docs)r- �LENIENT�upper� __members__r � OptionErrorr �emit)�clsr2 �_mode� r< �T/opt/bart/bart_venv/lib/python3.9/site-packages/setuptools/command/editable_wheel.py�convertA s �z_EditableMode.convertN) �__name__� __module__� __qualname__�__doc__�STRICTr5 r4 � classmethodr> r< r< r< r= r- 5 s r- 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 @ s� e Zd ZdZdZddddeejp"d�fgZdd � Zd d �d d �Z d d �dd�Z dd� Z dd� Z dd �dd�Z ddddd�dd�Zd d � Zd d �d d �Zddddd d!�d"d#�Zd d �d$d%�Zdd&�d'd(�Zd)d*� Zdd+�d,d-�Zdddd.d/�d0d1�ZdS )2�editable_wheelz�Build 'editable' wheel for development. This command is private and reserved for internal use of setuptools, users should rely on ``setuptools.build_meta`` APIs. zBDO NOT CALL DIRECTLY, INTERNAL ONLY: create PEP 660 editable wheel)z dist-dir=�dz-directory to put final built distributions in)zdist-info-dir=�Iz(path to a pre-build .dist-info directoryzmode=N� c C s d | _ d | _d | _d | _d S �N)�dist_dir� dist_info_dir� project_dirr2 ��selfr< r< r= �initialize_optionsv s z!editable_wheel.initialize_options�None�r3 c C s@ | j }|jptj| _|jp i | _t| jp6tj� | jd��| _d S )N�dist) � distribution�src_root�os�curdirrL � package_dirr rJ �path�join)rN rR r< r< r= �finalize_options| s z editable_wheel.finalize_optionsc C s� zD| j jdd� | �� | �d� | �d�}|�| j� | �|� W nL ty� } z4| j j pd| j � � }t � |d|� d�� � W Y d }~n d }~0 0 d S )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)rJ �mkdir�_ensure_dist_info�reinitialize_command�get_finalized_commandZwrite_wheelfilerK �_create_wheel_file� ExceptionrS �name�get_namer �add_note)rN r\ �ex�projectr< r< r= �run� s �zeditable_wheel.runc C sh | j d u r<tt| �d��}| j|_|�� |�� |j | _ n(t| j �� d�sPJ �t | j d�� � sdJ �d S )Nr$ z .dist-info�METADATA) rK r � dist_info_clsr_ rJ � output_dir�ensure_finalizedrh �str�endswithr �exists)rN r$ r< r< r= r^ � s z editable_wheel._ensure_dist_infoc C sD | j }|jsd S t| j| j�dd���� }t||||�}|�� d S )NrH �.) rS �namespace_packagesr rL rW �get�resolve�_NamespaceInstallerZinstall_namespaces)rN �installation_dirZ pth_prefixrR rT � installerr< r< r= �_install_namespaces� s z"editable_wheel._install_namespacesr1 c C s2 | j rt| j �jnt� }tt|�d��}t|d �S )Nz *.egg-info)rK r �parent�maprm �glob�next)rN � parent_dir� candidatesr< r< r= �_find_egg_info_dir� s z!editable_wheel._find_egg_info_dirrm r )rc �unpacked_wheel� build_lib�tmp_dirc C sL | j }t|�}t|�}tt||� d�d��}tt||� d�d��}tt||� d�d��} tt|jddd��} t|�| _d| _tt|jddd��} tt |jd dd��} | | _ | _ | _ | | _ | _| _| | _| _|| _|| _|�d �} d | _tt|�d ��}d|_t|�| _tt|�d ��}d|_| �� |_ | � � | � � | � � dS )a� Configure 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.data�data�headers�scriptsr% T)�reinit_subcommandsr" r& � build_scripts�pythonr' r# FN) rS rm r r � egg_info_clsr_ Zegg_baseZignore_egg_info_in_manifest� build_cls� install_cls� build_platlib� build_purelibr� �install_purelib�install_platlib� install_libr' r� �install_headers� install_data�get_command_obj� executable�install_scripts_clsZno_ep� build_temp� build_py_cls�compiler~ Zexisting_egg_info_dir�_set_editable_moderl )rN rc r r� r� rR �wheelr� r� r� r% r" r& r� r' r# r< r< r= �_configure_build� sF � �� � z editable_wheel._configure_buildc C sN | j }|�d�}|�� D ]0}|�|�}t|d�r8d|_qt|d�rd|_qdS )z8Set the ``editable_mode`` flag in the build sub-commandsr" � editable_modeT�inplaceN)rS r� �get_sub_commands�hasattrr� r� )rN rR r" �cmd_name�cmdr< r< r= r� � s z!editable_wheel._set_editable_modez tuple[list[str], dict[str, str]]c C sj g }i }| � d�}|�� D ]F}| � |�}t|d�rD|�|�� p@g � t|d�r|�|�� p\i � q||fS )Nr" � get_outputs�get_output_mapping)r` r� r� �extendr� �updater� )rN �files�mappingr" r� r� r< r< r= �_collect_build_outputs� s z%editable_wheel._collect_build_outputs)� dist_namer r� r� r3 c C sJ | � ||||� | �� | �� \}}| �d� | �d� | �d� ||fS )Nr� r� r� )r� �_run_build_subcommandsr� � _run_install)rN r� r r� r� r� r� r< r< r= �_run_build_commands s z"editable_wheel._run_build_commandsc C sP | � d�}|�� D ]8}| � |�}|dkr@t|�tur@| �|� q| �|� qdS )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` r� �typer� � _safely_run� run_command)rN r" rc r� r< r< r= r� s z%editable_wheel._run_build_subcommands)r� c C sH z | � |�W S tyB t�ddt�� � d|� d|� d�� Y n0 d S )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. )r� rb r r9 � traceback� format_exc)rN r� r< r< r= r� . s �� ��zeditable_wheel._safely_runc C s� ddl m} | �d�}|j}d�|�� �}d}|� d|� d|� d�}t| j|�}|�� r`|� � t |d�} t dd�} t d d�} | ��} | ��} | ��}t| t| j �j�}t � | j |� | �| |� | �|| | |�\}}| �||| �}|�R ||d ��&}||||� |�| � W d � n1 �s 0 Y W d � n1 �s>0 Y W d � n1 �s^0 Y W d � n1 �s~0 Y W d � n1 �s�0 Y |S ) Nr r) r$ �-z 0.editablez.whl)�suffixz .build-libz .build-temp�w)Zwheel.wheelfiler* r` rc rY Zget_tagr rJ ro �unlinkr rK �shutil�copytreerw r� �_select_strategyZ write_files)rN r\ r* r$ r� �tag� build_tag� archive_name� wheel_pathr r� Z build_tmp�unpacked�lib�tmpZunpacked_dist_infor� r� ZstrategyZ wheel_objr< r< r= ra J s, �z!editable_wheel._create_wheel_file)�categoryc C sD t | jd|� �d �}|r@|� r@t�d|� d�� | �d|� �� d S )NZhas_z Installing z as non editable�install_)�getattrrS �_logger�infor� )rN r� Z has_categoryr< r< r= r� f s zeditable_wheel._run_install�EditableStrategy)rc r� r� r3 c C s� d|� d|� �}t | j�}t�| j�}|tju rRtt | jd|��}t| j|||�S t | j�}t || j |�} |tj u } t | j �dhkr�| s�| r�| j �dd�} t| j|t || �g�S t| j|�S )zDDecides which strategy to use to implement an editable installation.� __editable__.r� r" rH rp )r rL r- r> r2 rC � _empty_dir� _LinkTreerS �_find_packages�_simple_layoutrW r4 �setrr � _StaticPth�_TopLevelFinder) rN rc r� r� Z build_namerL r2 � auxiliary_dir�packagesZhas_simple_layoutZis_compat_mode�src_dirr< r< r= r� l s z editable_wheel._select_strategy)r? r@ rA rB � descriptionr r- � user_optionsrO rZ rh r^ rw r~ r� r� r� r� r� r� ra r� r� r< r< r< r= rE h s* � ? rE c @ sB e Zd Zddddd�dd�Zdd �d d �Zd d ddd�dd�ZdS )r� r* � list[str]�Mapping[str, str]�object�r� r� r� r3 c C s d S rI r< �rN r� r� r� r< r< r= �__call__� s zEditableStrategy.__call__r( rQ c C s d S rI r< rM r< r< r= � __enter__� � zEditableStrategy.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | None�� _exc_type� _exc_value� _tracebackr3 c C s d S rI r< �rN r� r� r� r< r< r= �__exit__� s zEditableStrategy.__exit__N)r? r@ rA r� r� r� r< r< r< r= r� � s r� c @ sV e Zd Zddddd�dd�Zdd d dd �d d �Zdd�dd�Zddddd�dd�ZdS )r� r rm z list[Path]rP )rR rc � path_entriesr3 c C s || _ || _|| _d S rI )rR rc r� )rN rR rc r� r< r< r= �__init__� s z_StaticPth.__init__r* r� r� r� c C s> d� dd� | jD ��}t|� d��}|�d| j� d�|� d S )N� c s s | ]}t |�� �V qd S rI )rm rs )�.0�pr< r< r= � <genexpr>� r� z&_StaticPth.__call__.<locals>.<genexpr>r� �.pth)rY r� � _encode_pth�writestrrc )rN r� r� r� �entries�contentsr< r< r= r� � s z_StaticPth.__call__r( rQ c C s, dt ttj| j���d�}t�|t � | S )Nz_ Editable install will be performed using .pth file to extend `sys.path` with: z )�listry rU �fspathr� r� �warning�_LENIENT_WARNING�rN �msgr< r< r= r� � s �z_StaticPth.__enter__r� r� c C s d S rI r< r� r< r< r= r� � s z_StaticPth.__exit__N)r? r@ rA r� r� r� r� r< r< r< r= r� � s r� c s� e Zd ZdZdddddd�� fdd� Zd d d dd �� fd d� Zddd�dd�Zd"ddd�dd�Zd d�dd�Zdd�d d �Z d d d dd �d d!�Z � Z S )#r� a` 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. r rm r rP )rR rc r� r� r3 c s> t |�| _t |��� | _|�d�j| _t� �||| jg� d S )Nr# ) r r� rs r� r� � copy_file�_file�superr� )rN rR rc r� r� �� __class__r< r= r� � s z_LinkTree.__init__r* r� r� r� c s | � ||� t� �|||� d S rI )� _create_linksr� r� r� r� r< r= r� � s z_LinkTree.__call__r1 )�filer3 c C sR t t��6 t|��� �| j�}t|��tj d�W d � S 1 sD0 Y d S )N�/) r � ValueErrorr rs � relative_tor� rm �replacerU �sep)rN r� rX r< r< r= �_normalize_output� s 0z_LinkTree._normalize_outputN)�relative_output�src_filec C s6 | j | }|j�� s"|jjdd� | j|||d� d S )NT)�parents��link)r� rx �is_dirr] r� )rN r� r� r �destr< r< r= � _create_file� s z_LinkTree._create_file)�output_mappingc s� � j jddd� t� j �r dnd}� fdd�|�� D �}dd� |D �}|D ]&}� �|�}|rJ||vrJ� �||� qJ|�� D ]\}}� j|||d � qzd S ) NT)r r[ �sym�hardc 3 s | ]\}}� � |�|fV qd S rI )r� �r� �k�vrM r< r= r� � r� z*_LinkTree._create_links.<locals>.<genexpr>c S s i | ]\}}|d ur||�qS rI r< r r< r< r= � <dictcomp>� r� z+_LinkTree._create_links.<locals>.<dictcomp>r )r� r] �_can_symlink_files�itemsr� r ) rN �outputsr Z link_typeZ normalisedZmappings�output�relative�srcr< rM r= r� � s z_LinkTree._create_linksr( rQ c C s d}t �|t � | S )Nz=Strict editable install will be performed using a link tree. )r� r� �_STRICT_WARNINGr� r< r< r= r� � s z_LinkTree.__enter__r� r� c C s d| j � d�}t�d|� d S )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.)r� r r9 �rN r� r� r� r� r< r< r= r� � s �z_LinkTree.__exit__)N) r? r@ rA rB r� r� r� r r� r� r� � __classcell__r< r< r� r= r� � s r� c @ sp e Zd Zdddd�dd�Zdd�d d �Zd d�d d �Zddddd�dd�Zdd�dd�Zddddd�dd�ZdS ) r� r rm rP )rR rc r3 c C s || _ || _d S rI )rR rc )rN rR rc r< r< r= r� s z_TopLevelFinder.__init__z5tuple[str, str, dict[str, str], dict[str, list[str]]]rQ c s� �j jp tj}tt�j �t�j ��}�j jp.i }t|||�� t tt �j j pLg � �dd� t � �D ���}� �fdd��j j p|g D �}i � �|�}d�j� d�}t�|�}||||fS )Nc s s | ]}|g fV qd S rI r< )r� �nsr< r< r= r� r� z0_TopLevelFinder.template_vars.<locals>.<genexpr>c s" i | ]}|t |� �jjpd ��qS )rH )r rR rT �r� �pkg��rootsrN r< r= r s �z1_TopLevelFinder.template_vars.<locals>.<dictcomp>r� z.finder)rR rT rU rV r r� �_find_top_level_modulesrW �_find_package_roots�dict�_find_namespacesr� �_find_virtual_namespacesrq rc r Zsafe_identifier) rN rT Z top_levelrW � namespaces_Zlegacy_namespacesr� rc �finderr< r r= � template_vars s" �� � z _TopLevelFinder.template_varszIterator[tuple[str, bytes]]c c s` | � � \}}}}tt|||�d�}|� d�|fV td|� d|� d��}d| j� d�|fV d S )N�utf-8z.pyzimport z; z .install()r� r� )r# �bytes�_finder_templater� rc )rN r" rc r� r! �contentr< r< r= �get_implementation s z"_TopLevelFinder.get_implementationr* r� r� r� c C s" | � � D ]\}}|�||� qd S rI )r( r� )rN r� r� r� r� r' r< r< r= r� ) s z_TopLevelFinder.__call__r( c C s d}t �|t � | S )Nz=Editable install will be performed using a meta path finder. )r� r� r� r� r< r< r= r� / s z_TopLevelFinder.__enter__r� r� c C s d}t �d|� d S )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 )r r9 r r< r< r= r� 4 s z_TopLevelFinder.__exit__N) r? r@ rA r� r# r( r� r� r� r< r< r< r= r� s r� rm r% )r' r3 c C s` t �� �D}t j|tjd�}|�| � |�� |�d� |�� W d � S 1 sR0 Y dS )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()``). ��encodingr N) �io�BytesIO� TextIOWrapperr Z PTH_ENCODING�write�flush�seek�read)r' �buffer�wrapperr< r< r= r� A s r� r �bool)�base_dirr3 c C s t t| �� �d���}t|d�t|d� }}|jddd� tttt��P t � ||� |� � r�|j dd�dkr�W d � W d � dS W d � n1 s�0 Y zt � ||� W n2 ty� } zd}t|�|�W Y d }~n d }~0 0 W d � d S 1 �s 0 Y d S ) N)�dirz file1.txtz file2.txtZfile1r$ r) Tz�File system does not seem to support either symlinks or hard links. Strict editable installs require one of them to be supported.F)r rm rs r � write_textr �AttributeError�NotImplementedError�OSErrorrU �symlink� is_symlink� read_textr rb �LinksNotSupported)r5 r� Zpath1Zpath2rf r� r< r< r= r V s :� r z Iterable[str]zdict[str, str]r )r� rW rL r3 c sZ � �fdd�| D �}|s*t � �i dhfv S tj�tt|�� ���t�fdd�|�� D ��S )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 c s i | ]}|t |� ���qS r< r r )rW rL r< r= r � r� z"_simple_layout.<locals>.<dictcomp>rH c 3 s0 | ](\}}t �t� g|�d ��R � |�V qdS �rp N)r Z same_pathr �split)r� �key�value)rx r< r= r� � s �z!_simple_layout.<locals>.<genexpr>)r� rU rX � commonpathr � _parent_pathr �all)r� rW rL Zlayoutr< )rW rx rL r= r� j s �r� c C s |� | �}|�dtj �S )a7 Infer 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� )� removesuffix�rstriprU r� )r �pkg_pathrx r< r< r= rD � s rD r z Iterator[str])rR r3 c c s| t | jp g �E d H | jp g }dd� |D �}| jr<| jV n | jpDg }|dd� |D �7 }|D ]}|�d�\}}}|V q\d S )Nc S s g | ]}d |v r|�qS �rp r< �r� �modr< r< r= � <listcomp>� r� z"_find_packages.<locals>.<listcomp>c S s g | ]}d |j v r|j �qS rI �rc �r� �xr< r< r= rL � r� rp )�iterr� � py_modules� ext_package� ext_modules� rpartition)rR rQ Znested_modulesrS �module�package�_r< r< r= r� � s r� c c sF | j pg }dd� |D �E d H | jsB| jp,g }dd� |D �E d H d S )Nc s s | ]}d |vr|V qdS r? r< rJ r< r< r= r� � r� z*_find_top_level_modules.<locals>.<genexpr>c s s | ]}d |j vr|j V qdS r? rM rN r< r< r= r� � r� )rQ rR rS )rR rQ rS r< r< r= r � s r r� )r� rW rT r3 c s � �fdd�t | �D �}t|�S )Nc s i | ]}|t t|� ����qS r< )�_absolute_rootr r �rW rT r< r= r � s �z'_find_package_roots.<locals>.<dictcomp>)�sorted�_remove_nested)r� rW rT � pkg_rootsr< rY r= r � s �r )rX r3 c C s8 t | �}|j}|�� r"t|�� �S t|�� |j �S dS )z(Works for packages and top-level modulesN)r rx ro rm rs rc )rX Zpath_rx r< r< r= rX � s rX )r\ r3 c c st | D ]j}d|vrq|� d�}tt|�d dd�D ]<}d�|d|� �}tt|| d��}|�� rf|| vr0|V q0qdS )a8 By 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. rp r! r ���NrH )r@ �range�lenrY r r ro )r\ r �parts�iZ partial_namerX r< r< r= r � s r r� z Iterator[tuple[str, list[str]]])r� r\ r3 c c s@ | D ]6}t ||d�}t|��� rt|d��� s||gfV qd S )NrH z __init__.py)r r ro )r� r\ r rX r< r< r= r � s r c sP t | �� �}tt| �� ��D ].\�� t� �fdd�| �� D ��r |��� q |S )Nc 3 s( | ] \}}�|ko t �� ||�V qd S rI )� _is_nested)r� �other� other_path�rX r r< r= r� � s �z!_remove_nested.<locals>.<genexpr>)r �copy�reversedr� r �any�pop)r\ r r< re r= r[ � s � r[ )r rH rx � parent_pathr3 c C sH t �|�}| �|dd��d��d�}| �|�oF|t �t|g|�R � �kS )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 rH r! rp )r �normpathr� �stripr@ � startswithr )r rH rx rj Z norm_pkg_path�restr< r< r= rb s �rb )�dir_r3 c C s t j| dd� t�| � | S )zFCreate a directory ensured to be empty. Existing files may be removed.T)� ignore_errors)r �rmtreerU �makedirs)ro r< r< r= r� s r� c @ s* e Zd Zdd�dd�Zdd� Zdd� Zd S ) rt rP rQ c C s( || _ || _|| _|| _g | _d| _d S )NF)rS rT ru � editable_namer �dry_run)rN rS ru rs rT r< r< r= r� s z _NamespaceInstaller.__init__c C s t j�| j| j| j �S )zInstallation target.)rU rX rY ru rs Z nspkg_extrM r< r< r= �_get_nspkg_file& s z#_NamespaceInstaller._get_nspkg_filec C s t t| j��S )z1Where the modules/packages should be loaded from.)�reprrm rT rM r< r< r= � _get_root* s z _NamespaceInstaller._get_rootN)r? r@ rA r� ru rw r< r< r< r= rt s rt a 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 zdict[str, list[str]])rc r� r r3 c C s* t t|�� t�d�d��}tj| ||d�S )z_Create a string containing the code for the``MetaPathFinder`` and ``PathEntryFinder``. r )rA �rc r� r )r rZ r �operator� itemgetter�_FINDER_TEMPLATE�formatrx r< r< r= r& � s r& c @ s e Zd ZdZdS )r> zCFile system does not seem to support either symlinks or hard links.N)r? r@ rA rB r< r< r< r= r> � s r> )brB � __future__r r+ �loggingry rU r� r� �collections.abcr r r � contextlibr �enumr �inspectr � itertoolsr r �pathlibr �tempfiler �typesr �typingr r r r rH r r r r r r r r0 r r Z discoveryr rR r �warningsr r r" r� r# r� r$ rj r% r� r& r� r' r� Ztyping_extensionsr( Z_vendor.wheel.wheelfiler* r+ � getLoggerr? r� r- r r� rE r� r� r� r� r� r r� rD r� r r rX r r r[ rb r� Z Installerrt r{ r& Z FileErrorr> r< r< r< r= �<module> sx ) ! NA) Y
cải xoăn