HEX

File: //usr/local/lib/python3.10/dist-packages/pip/_internal/metadata/__pycache__/base.cpython-310.pyc
o

��hLc�@s�ddlmZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlmZm
Z
mZmZddlmZmZmZmZmZddlmZddlmZmZddlmZmZddlmZdd	l m!Z!dd
l"m#Z#m$Z$ddl%m&Z&m'Z'm(Z(ddl)m*Z*dd
l+m,Z,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z3ee4ej5fZ6e�7e8�Z9Gdd�de�Z:d'dd�Z;Gdd�de�Z<Gdd�de�Z=Gdd �d �Z>Gd!d"�d"e�Z?Gd#d$�d$e?�Z@Gd%d&�d&e?�ZAdS)(�)�annotationsN)�
Collection�	Container�Iterable�Iterator)�IO�Any�
NamedTuple�Protocol�Union)�Requirement)�InvalidSpecifier�SpecifierSet)�NormalizedName�canonicalize_name)�Version)�NoneMetadataError)�
site_packages�	user_site)�DIRECT_URL_METADATA_NAME�	DirectUrl�DirectUrlValidationError)�stdlib_pkgs)�egg_link_path_from_sys_path)�is_local�normalize_path)�url_to_path�)�msg_to_jsonc@s6eZdZed
dd��Zed
dd��Zed
dd��Zd	S)�BaseEntryPoint�return�strcC�t���N��NotImplementedError��self�r(�F/usr/local/lib/python3.10/dist-packages/pip/_internal/metadata/base.py�name-�zBaseEntryPoint.namecCr"r#r$r&r(r(r)�value1r+zBaseEntryPoint.valuecCr"r#r$r&r(r(r)�group5r+zBaseEntryPoint.groupN�r r!)�__name__�
__module__�__qualname__�propertyr*r,r-r(r(r(r)r,sr�entry�tuple[str, ...]�infor r!cCsj|r)|ddkr)|r|ddkr|d7}n|dd�}|dd�}|r)|ddksttjg|�|�R��S)a�Convert a legacy installed-files.txt path into modern RECORD path.

    The legacy format stores paths relative to the info directory, while the
    modern format stores paths relative to the package root, e.g. the
    site-packages directory.

    :param entry: Path parts of the installed-files.txt entry.
    :param info: Path parts of the egg-info directory relative to package root.
    :returns: The converted entry.

    For best compatibility with symlinks, this does not use ``abspath()`` or
    ``Path.resolve()``, but tries to work with path parts:

    1. While ``entry`` starts with ``..``, remove the equal amounts of parts
       from ``info``; if ``info`` is empty, start appending ``..`` instead.
    2. Join the two directly.
    r�..���)r6Nr�r!�pathlib�Path)r3r5r(r(r)�_convert_installed_files_path:s
�r;c@s&eZdZUded<ded<ded<dS)�
RequiresEntryr!�requirement�extra�markerN)r/r0r1�__annotations__r(r(r(r)r<Xs
r<c@s4eZdZedzdd��Zed{d
d��Zed|dd��Zd}dd�Zd}dd�Ze	d~dd��Z
e	d~dd��Ze	d~dd��Ze	d~dd��Z
e	ddd ��Ze	dd!d"��Ze	dd#d$��Ze	dd%d&��Ze	d�d(d)��Ze	d�d+d,��Ze	d}d-d.��Ze	d}d/d0��Ze	d�d2d3��Ze	d}d4d5��Ze	dd6d7��Ze	dd8d9��Ze	dd:d;��Ze	dd<d=��Ze	dd>d?��Zd�dBdC�Zd�dEdF�Zd�dGdH�Zd�dJdK�Z d�dMdN�Z!e"j#d�dOdP��Z$e	d�dRdS��Z%e	d~dTdU��Z&e	d}dVdW��Z'e	d�dYdZ��Z(d�d�d_d`�Z)d�dbdc�Z*d�dedf�Z+d�dhdi�Z,d�djdk�Z-d�dldm�Z.d�dodp�Z/d�dqdr�Z0d�dsdt�Z1d�dwdx�Z2dyS)��BaseDistribution�	directoryr!r cCr")z�Load the distribution from a metadata directory.

        :param directory: Path to a metadata directory, e.g. ``.dist-info``.
        r$)�clsrBr(r(r)�from_directory_�zBaseDistribution.from_directory�metadata_contents�bytes�filename�project_namecCr")a�Load the distribution from the contents of a METADATA file.

        This is used to implement PEP 658 by generating a "shallow" dist object that can
        be used for resolution without downloading or building the actual dist yet.

        :param metadata_contents: The contents of a METADATA file.
        :param filename: File name for the dist with this metadata.
        :param project_name: Name of the project this dist represents.
        r$)rCrFrHrIr(r(r)�from_metadata_file_contentsgsz,BaseDistribution.from_metadata_file_contents�wheel�Wheelr*cCr")aLoad the distribution from a given wheel.

        :param wheel: A concrete wheel definition.
        :param name: File name of the wheel.

        :raises InvalidWheel: Whenever loading of the wheel causes a
            :py:exc:`zipfile.BadZipFile` exception to be thrown.
        :raises UnsupportedWheel: If the wheel is a valid zip, but malformed
            internally.
        r$)rCrKr*r(r(r)�
from_wheely�zBaseDistribution.from_wheelcCs|j�d|j�d|j�d�S)N� z (�))�raw_name�raw_version�locationr&r(r(r)�__repr__�szBaseDistribution.__repr__cCs|j�d|j��S)NrO)rQrRr&r(r(r)�__str__�szBaseDistribution.__str__�
str | NonecCr")a�Where the distribution is loaded from.

        A string value is not necessarily a filesystem path, since distributions
        can be loaded from other sources, e.g. arbitrary zip archives. ``None``
        means the distribution is created in-memory.

        Do not canonicalize this value with e.g. ``pathlib.Path.resolve()``. If
        this is a symbolic link, we want to preserve the relative path between
        it and files in the distribution.
        r$r&r(r(r)rS�rNzBaseDistribution.locationcCs8|j}|r|��rt|j�SdSt|j�}|r|jSdS)z�The project location for editable distributions.

        This is the directory where pyproject.toml or setup.py is located.
        None if the distribution is not installed in editable mode.
        N)�
direct_url�is_local_editabler�urlrrQrS)r'rW�
egg_link_pathr(r(r)�editable_project_location�s
	
�z*BaseDistribution.editable_project_locationcCr")a�The distribution's "installed" location.

        This should generally be a ``site-packages`` directory. This is
        usually ``dist.location``, except for legacy develop-installed packages,
        where ``dist.location`` is the source code location, and this is where
        the ``.egg-link`` file is.

        The returned location is normalized (in particular, with symlinks removed).
        r$r&r(r(r)�installed_location�sz#BaseDistribution.installed_locationcCr")a/Location of the .[egg|dist]-info directory or file.

        Similarly to ``location``, a string value is not necessarily a
        filesystem path. ``None`` means the distribution is created in-memory.

        For a modern .dist-info installation on disk, this should be something
        like ``{location}/{raw_name}-{version}.dist-info``.

        Do not canonicalize this value with e.g. ``pathlib.Path.resolve()``. If
        this is a symbolic link, we want to preserve the relative path between
        it and other files in the distribution.
        r$r&r(r(r)�
info_location�szBaseDistribution.info_location�boolcCs|j}|sdSt�|���S)aWhether this distribution is installed with legacy distutils format.

        A distribution installed with "raw" distutils not patched by setuptools
        uses one single file at ``info_location`` to store metadata. We need to
        treat this specially on uninstallation.
        F)r]r9r:�is_file�r'r]r(r(r)�installed_by_distutils�sz'BaseDistribution.installed_by_distutilscCs|j}|sdSt�|�jdkS)z�Whether this distribution is installed as an egg.

        This usually indicates the distribution was installed by (older versions
        of) easy_install.
        Fz.egg)rSr9r:�suffix�r'rSr(r(r)�installed_as_egg�sz!BaseDistribution.installed_as_eggcC�*|j}|sdS|�d�sdSt�|���S)a�Whether this distribution is installed with the ``.egg-info`` format.

        This usually indicates the distribution was installed with setuptools
        with an old pip version or with ``single-version-externally-managed``.

        Note that this ensure the metadata store is a directory. distutils can
        also installs an ``.egg-info``, but as a file, not a directory. This
        property is *False* for that case. Also see ``installed_by_distutils``.
        Fz	.egg-info�r]�endswithr9r:�is_dirr`r(r(r)�"installed_with_setuptools_egg_info�s
z3BaseDistribution.installed_with_setuptools_egg_infocCre)aaWhether this distribution is installed with the "modern format".

        This indicates a "modern" installation, e.g. storing metadata in the
        ``.dist-info`` directory. This applies to installations made by
        setuptools (but through pip, not directly), or anything using the
        standardized build backend interface (PEP 517).
        Fz
.dist-inforfr`r(r(r)�installed_with_dist_info�s	
z)BaseDistribution.installed_with_dist_inforcCr"r#r$r&r(r(r)�canonical_namer+zBaseDistribution.canonical_namercCr"r#r$r&r(r(r)�versionr+zBaseDistribution.versioncCr"r#r$r&r(r(r)rRr+zBaseDistribution.raw_versioncCs|j�dd�S)z�Convert a project name to its setuptools-compatible filename.

        This is a copy of ``pkg_resources.to_filename()`` for compatibility.
        �-�_)rQ�replacer&r(r(r)�setuptools_filenamesz$BaseDistribution.setuptools_filename�DirectUrl | Nonec
Csrz|�t�}Wn
tyYdSwzt�|�WSttjtfy8}zt	�
dt|j|�WYd}~dSd}~ww)z�Obtain a DirectUrl from this distribution.

        Returns None if the distribution has no `direct_url.json` metadata,
        or if `direct_url.json` is invalid.
        NzError parsing %s for %s: %s)�	read_textr�FileNotFoundErrorr�	from_json�UnicodeDecodeError�json�JSONDecodeErrorr�logger�warningrk)r'�content�er(r(r)rWs*�����zBaseDistribution.direct_urlc
CsPz|�d�}Wn
tttfyYdSw|��D]}|��}|r%|SqdS)N�	INSTALLER�)rr�OSError�
ValueErrorr�
splitlines�strip)r'�installer_text�line�cleaned_liner(r(r)�	installer9s��zBaseDistribution.installercCs
|�d�S)N�	REQUESTED)r_r&r(r(r)�	requestedE�
zBaseDistribution.requestedcC�
t|j�Sr#)r^r[r&r(r(r)�editableIr�zBaseDistribution.editablecCs|jdurdSt|j�S)z|If distribution is installed in the current virtual environment.

        Always True if we're not in a virtualenv.
        NF)r\rr&r(r(r)�localMs

zBaseDistribution.localcC�&|jdus	tdurdS|j�tt��S�NF)r\r�
startswithrr&r(r(r)�in_usersiteW�zBaseDistribution.in_usersitecCr�r�)r\rr�rr&r(r(r)�in_site_packages]r�z!BaseDistribution.in_site_packages�path�InfoPathcCr")z7Check whether an entry in the info directory is a file.r$�r'r�r(r(r)r_cr+zBaseDistribution.is_file�
Iterator[str]cCr")z�Find distutils 'scripts' entries metadata.

        If 'scripts' is supplied in ``setup.py``, distutils records those in the
        installed distribution's ``scripts`` directory, a file for each script.
        r$r&r(r(r)�iter_distutils_script_namesgrEz,BaseDistribution.iter_distutils_script_namescCr")z�Read a file in the info directory.

        :raise FileNotFoundError: If ``path`` does not exist in the directory.
        :raise NoneMetadataError: If ``path`` exists in the info directory, but
            cannot be read.
        r$r�r(r(r)rro�zBaseDistribution.read_text�Iterable[BaseEntryPoint]cCr"r#r$r&r(r(r)�iter_entry_pointsx�z"BaseDistribution.iter_entry_points�email.message.MessagecCr"r#r$r&r(r(r)�_metadata_impl{r�zBaseDistribution._metadata_implcCs|��}|�|�|S)aMetadata of distribution parsed from e.g. METADATA or PKG-INFO.

        This should return an empty message if the metadata file is unavailable.

        :raises NoneMetadataError: If the metadata file is available, but does
            not contain valid metadata.
        )r��_add_egg_info_requires)r'�metadatar(r(r)r�~s	
zBaseDistribution.metadata�dict[str, Any]cCr�)aPEP 566 compliant JSON-serializable representation of METADATA or PKG-INFO.

        This should return an empty dict if the metadata file is unavailable.

        :raises NoneMetadataError: If the metadata file is available, but does
            not contain valid metadata.
        )rr�r&r(r(r)�
metadata_dict�s
	zBaseDistribution.metadata_dictcCs|j�d�S)zDValue of "Metadata-Version:" in distribution metadata, if available.zMetadata-Version)r��getr&r(r(r)�metadata_version�sz!BaseDistribution.metadata_versioncCs|j�d|j�S)z*Value of "Name:" in distribution metadata.�Name)r�r�rkr&r(r(r)rQ�szBaseDistribution.raw_namerc
Csl|j�d�}|dur
t�Sz	tt|��}W|Sty5}zd}t�||j|�t�WYd}~Sd}~ww)z�Value of "Requires-Python:" in distribution metadata.

        If the key does not exist or contains an invalid value, an empty
        SpecifierSet should be returned.
        zRequires-PythonNz-Package %r has an invalid Requires-Python: %s)r�r�rr!r
rxryrQ)r'r,�specr{�messager(r(r)�requires_python�s���z BaseDistribution.requires_pythonr(�extras�Collection[str]�Iterable[Requirement]cCr")z�Dependencies of this distribution.

        For modern .dist-info distributions, this is the collection of
        "Requires-Dist:" entries in distribution metadata.
        r$)r'r�r(r(r)�iter_dependencies�rEz"BaseDistribution.iter_dependencies�
Iterable[str]cCs|j�dg�S)zRaw Requires-Dist metadata.�
Requires-Dist)r��get_allr&r(r(r)�iter_raw_dependencies�sz&BaseDistribution.iter_raw_dependencies�Iterable[NormalizedName]cCr")ajExtras provided by this distribution.

        For modern .dist-info distributions, this is the collection of
        "Provides-Extra:" entries in distribution metadata.

        The return value of this function is expected to be normalised names,
        per PEP 685, with the returned value being handled appropriately by
        `iter_dependencies`.
        r$r&r(r(r)�iter_provided_extras�s
z%BaseDistribution.iter_provided_extras�Iterator[str] | NonecCs<z|�d�}Wn
tyYdSwdd�t�|���D�S)N�RECORDcss"�|]}tt�|d��VqdS)rNr8)�.0�rowr(r(r)�	<genexpr>�s� zFBaseDistribution._iter_declared_entries_from_record.<locals>.<genexpr>)rrrs�csv�readerr�)r'�textr(r(r)�"_iter_declared_entries_from_record�s�z3BaseDistribution._iter_declared_entries_from_recordcs�z|�d�}Wn
tyYdSwdd�|jdd�D�}|j}|j}|dus+|dur-|Sz
t�|��|��WntyB|YSw�j	sH|S�fdd�|D�S)Nzinstalled-files.txtcss�|]}|r|VqdSr#r(�r��pr(r(r)r��s�zFBaseDistribution._iter_declared_entries_from_legacy.<locals>.<genexpr>F)�keependsc3s$�|]
}tt�|�j�j�VqdSr#)r;r9r:�partsr���info_relr(r)r��s
��
�)
rrrsr�rSr]r9r:�relative_torr�)r'r��paths�rootr5r(r�r)�"_iter_declared_entries_from_legacy�s(��
�z3BaseDistribution._iter_declared_entries_from_legacycCs|��p|��S)a�Iterate through file entries declared in this distribution.

        For modern .dist-info distributions, this is the files listed in the
        ``RECORD`` metadata file. For legacy setuptools distributions, this
        comes from ``installed-files.txt``, with entries normalized to be
        compatible with the format used by ``RECORD``.

        :return: An iterator for listed entries, or None if the distribution
            contains neither ``RECORD`` nor ``installed-files.txt``.
        )r�r�r&r(r(r)�iter_declared_entries�s�z&BaseDistribution.iter_declared_entries�Iterator[RequiresEntry]ccs��z|�d�}Wn
tyYdSwd}}|��D],}|��}|r(|�d�r)q|�d�r?|�d�r?|�d��d�\}}}qt|||d	�VqdS)
a�Parse a ``requires.txt`` in an egg-info directory.

        This is an INI-ish format where an egg-info stores dependencies. A
        section name describes extra other environment markers, while each entry
        is an arbitrary string (not a key-value pair) representing a dependency
        as a requirement string (no markers).

        There is a construct in ``importlib.metadata`` called ``Sectioned`` that
        does mostly the same, but the format is currently considered private.
        zrequires.txtNr}�#�[�]z[]�:)r=r>r?)rrrsr�r�r�rg�	partitionr<)r'rzr>r?r�rnr(r(r)�_iter_requires_txt_entries�s ���z+BaseDistribution._iter_requires_txt_entriesccs>�dh}|��D]}t|j�}||vrq|�|�|VqdS)z'Get extras from the egg-info directory.r}N)r�rr>�add)r'�known_extrasr3r>r(r(r)�_iter_egg_info_extrass�

�z&BaseDistribution._iter_egg_info_extrasccs��|��D]9}t|j�}|r|jrd|j�d|�d�}n|r%d|�d�}n	|jr,|j}nd}|r:|j�d|��Vq|jVqdS)a�Get distribution dependencies from the egg-info directory.

        To ease parsing, this converts a legacy dependency entry into a PEP 508
        requirement string. Like ``_iter_requires_txt_entries()``, there is code
        in ``importlib.metadata`` that does mostly the same, but not do exactly
        what we need.

        Namely, ``importlib.metadata`` does not normalize the extra name before
        putting it into the requirement string, which causes marker comparison
        to fail because the dist-info format do normalize. This is consistent in
        all currently available PEP 517 backends, although not standardized.
        �(z) and extra == "�"z
extra == "r}z ; N)r�rr>r?r=)r'r3r>r?r(r(r)�_iter_egg_info_dependenciess�


�z,BaseDistribution._iter_egg_info_dependenciesr��NonecCsH|�d�s|��D]}||d<q	|�d�s |��D]}||d<qdSdS)z6Add egg-info requires.txt information to the metadata.r�zProvides-ExtraN)r�r�r�)r'r��depr>r(r(r)r�9s



�z'BaseDistribution._add_egg_info_requiresN)rBr!r rA)rFrGrHr!rIr!r rA)rKrLr*r!r rAr.)r rV)r r^)r r)r r)r rq)r�r�r r^)r r�)r�r�r r!)r r�)r r�)r r�)r r)r()r�r�r r�)r r�)r r�)r r�)r r�)r�r�r r�)3r/r0r1�classmethodrDrJrMrTrUr2rSr[r\r]rardrirjrkrlrRrprWr�r�r�r�r�r�r_r�rrr�r��	functools�cached_propertyr�r�r�rQr�r�r�r�r�r�r�r�r�r�r�r(r(r(r)rA^s�



	



	










rAc@s`eZdZdZeddd��Zed dd��Zd!dd
�Zd"dd�Zd"dd�Z	de
dddfd#dd�ZdS)$�BaseEnvironmentz6An environment containing distributions to introspect.r cCr"r#r$)rCr(r(r)�defaultFr+zBaseEnvironment.defaultr��list[str] | NonecCr"r#r$)rCr�r(r(r)�
from_pathsJr+zBaseEnvironment.from_pathsr*r!�BaseDistribution | NonecCr")z�Given a requirement name, return the installed distributions.

        The name may not be normalized. The implementation must canonicalize
        it for lookup.
        r$)r'r*r(r(r)�get_distributionNrEz BaseEnvironment.get_distribution�Iterator[BaseDistribution]cCr")aIterate through installed distributions.

        This function should be implemented by subclass, but never called
        directly. Use the public ``iter_distribution()`` instead, which
        implements additional logic to make sure the distributions are valid.
        r$r&r(r(r)�_iter_distributionsVr�z#BaseEnvironment._iter_distributionsccsF�|��D]}tjd|jtjd�}|st�d|j|j�q|VqdS)zBIterate through all installed distributions without any filtering.z)^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$)�flagsz%Ignoring invalid distribution %s (%s)N)r��re�matchrk�
IGNORECASErxryrS)r'�dist�project_name_validr(r(r)�iter_all_distributions_s ����z&BaseEnvironment.iter_all_distributionsTF�
local_onlyr^�skip�Container[str]�include_editables�editables_only�	user_onlycsb|��}|r
dd�|D�}|sdd�|D�}|rdd�|D�}|r(dd�|D�}�fdd�|D�S)a/Return a list of installed distributions.

        This is based on ``iter_all_distributions()`` with additional filtering
        options. Note that ``iter_installed_distributions()`` without arguments
        is *not* equal to ``iter_all_distributions()``, since some of the
        configurations exclude packages by default.

        :param local_only: If True (default), only return installations
        local to the current virtualenv, if in a virtualenv.
        :param skip: An iterable of canonicalized project names to ignore;
            defaults to ``stdlib_pkgs``.
        :param include_editables: If False, don't report editables.
        :param editables_only: If True, only report editables.
        :param user_only: If True, only report installations in the user
        site directory.
        cs��|]}|jr|VqdSr#)r��r��dr(r(r)r����z?BaseEnvironment.iter_installed_distributions.<locals>.<genexpr>css�|]}|js|VqdSr#�r�r�r(r(r)r��r�csr�r#r�r�r(r(r)r��r�csr�r#)r�r�r(r(r)r��r�c3s�|]
}|j�vr|VqdSr#)rkr��r�r(r)r��s�)r�)r'r�r�r�r�r��itr(r�r)�iter_installed_distributionstsz,BaseEnvironment.iter_installed_distributionsN)r r�)r�r�r r�)r*r!r r�)r r�)r�r^r�r�r�r^r�r^r�r^r r�)r/r0r1�__doc__r�r�r�r�r�r�rr�r(r(r(r)r�Cs


	�r�c@s eZdZUded<ddd�ZdS)	rLr!rSr �zipfile.ZipFilecCr"r#r$r&r(r(r)�
as_zipfile�r�zWheel.as_zipfileN�r r�)r/r0r1r@r�r(r(r(r)rL�s
rLc@s eZdZddd�Zddd	�Zd
S)
�FilesystemWheelrSr!r r�cCs
||_dSr#)rSrcr(r(r)�__init__�s
zFilesystemWheel.__init__r�cC�tj|jdd�S�NT)�
allowZip64)�zipfile�ZipFilerSr&r(r(r)r���zFilesystemWheel.as_zipfileN)rSr!r r�r��r/r0r1r�r�r(r(r(r)r��s
r�c@s eZdZd
dd�Zdd
d�ZdS)�MemoryWheelrSr!�stream�	IO[bytes]r r�cCs||_||_dSr#)rSr)r'rSrr(r(r)r��s
zMemoryWheel.__init__r�cCr�r�)r�r�rr&r(r(r)r��r�zMemoryWheel.as_zipfileN)rSr!rrr r�r�rr(r(r(r)r�s
r)r3r4r5r4r r!)B�
__future__rr��
email.message�emailr�rv�loggingr9r�r��collections.abcrrrr�typingrrr	r
r�"pip._vendor.packaging.requirementsr� pip._vendor.packaging.specifiersr
r�pip._vendor.packaging.utilsrr�pip._vendor.packaging.versionr�pip._internal.exceptionsr�pip._internal.locationsrr�pip._internal.models.direct_urlrrr�pip._internal.utils.compatr�pip._internal.utils.egg_linkr�pip._internal.utils.miscrr�pip._internal.utils.urlsr�_jsonrr!�PurePathr��	getLoggerr/rxrr;r<rAr�rLr�rr(r(r(r)�<module>sH

hU