
    4ՔhLc                        S SK Jr  S SKrS SKrS SKrS SKrS SKrS SKrS SK	r	S SK
r
S SKJrJrJrJr  S SKJrJrJrJrJr  S SKJr  S SKJrJr  S SKJrJr  S SKJr  S S	K J!r!  S S
K"J#r#J$r$  S SK%J&r&J'r'J(r(  S SK)J*r*  S SK+J,r,  S SK-J.r.J/r/  S SK0J1r1  SSK2J3r3  \\4\Rj                  4   r6\Rn                  " \85      r9 " S S\5      r:      S!S jr; " S S\5      r< " S S\5      r= " S S5      r> " S S\5      r? " S S\?5      r@ " S S \?5      rAg)"    )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                  P    \ rS rSr\SS j5       r\SS j5       r\SS j5       rSrg)BaseEntryPoint,   c                    [        5       eNNotImplementedErrorselfs    S/var/www/auris/envauris/lib/python3.13/site-packages/pip/_internal/metadata/base.pynameBaseEntryPoint.name-       !##    c                    [        5       er$   r%   r'   s    r)   valueBaseEntryPoint.value1   r,   r-   c                    [        5       er$   r%   r'   s    r)   groupBaseEntryPoint.group5   r,   r-    Nreturnstr)	__name__
__module____qualname____firstlineno__propertyr*   r/   r2   __static_attributes__r4   r-   r)   r!   r!   ,   s<    $ $ $ $ $ $r-   r!   c                    U (       a;  U S   S:X  a2  U(       a	  US   S:X  a  US-  nOUSS nU SS n U (       a  U S   S:X  a  M2  [        [        R                  " / UQU Q76 5      $ )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   ..)r?   Nr   r7   pathlibPath)entryinfos     r)   _convert_installed_files_pathrF   :   sm    * E!H$tBx4'GOD9Dab	 E!H$ w||*T*E*++r-   c                  4    \ rS rSr% S\S'   S\S'   S\S'   Srg)RequiresEntryX   r7   requirementextramarkerr4   N)r8   r9   r:   r;   __annotations__r=   r4   r-   r)   rH   rH   X   s    JKr-   rH   c                     \ rS rSr\S0S j5       r\        S1S j5       r\S2S j5       rS3S jrS3S jr	\
S4S j5       r\
S4S j5       r\
S4S	 j5       r\
S4S
 j5       r\
S5S j5       r\
S5S j5       r\
S5S j5       r\
S5S j5       r\
S6S j5       r\
S7S j5       r\
S3S j5       r\
S3S j5       r\
S8S j5       r\
S3S j5       r\
S5S j5       r\
S5S j5       r\
S5S j5       r\
S5S j5       r\
S5S j5       rS9S jrS:S jrS;S jr S<S jr!S=S jr"\#RH                  S=S j5       r%\
S>S  j5       r&\
S4S! j5       r'\
S3S" j5       r(\
S?S# j5       r)S@SAS% jjr*SBS& jr+SCS' jr,SDS( jr-SDS) jr.SDS* jr/SES+ jr0SBS, jr1SBS- jr2SFS. jr3S$r4g/)GBaseDistribution^   c                    [        5       e)zwLoad the distribution from a metadata directory.

:param directory: Path to a metadata directory, e.g. ``.dist-info``.
r%   )cls	directorys     r)   from_directoryBaseDistribution.from_directory_        "##r-   c                    [        5       e)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%   )rR   metadata_contentsfilenameproject_names       r)   from_metadata_file_contents,BaseDistribution.from_metadata_file_contentsg   s      "##r-   c                    [        5       e)aG  Load 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%   )rR   wheelr*   s      r)   
from_wheelBaseDistribution.from_wheely        "##r-   c                T    U R                    SU R                   SU R                   S3$ )N z ())raw_nameraw_versionlocationr'   s    r)   __repr__BaseDistribution.__repr__   s*    --$"2"2!32dmm_AFFr-   c                8    U R                    SU R                   3$ )Nrc   )re   rf   r'   s    r)   __str__BaseDistribution.__str__   s    --$"2"2!344r-   c                    [        5       e)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'   s    r)   rg   BaseDistribution.location   ra   r-   c                    U R                   nU(       a,  UR                  5       (       a  [        UR                  5      $  g[	        U R
                  5      nU(       a  U R                  $ g)zThe 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   urlr   re   rg   )r(   rp   egg_link_paths      r)   editable_project_location*BaseDistribution.editable_project_location   sZ     __
++--":>>22 .  8FM }}$r-   c                    [        5       e)ab  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'   s    r)   installed_location#BaseDistribution.installed_location   s     "##r-   c                    [        5       e)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'   s    r)   info_locationBaseDistribution.info_location   s     "##r-   c                r    U R                   nU(       d  g[        R                  " U5      R                  5       $ )zWhether 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)rz   rB   rC   is_filer(   rz   s     r)   installed_by_distutils'BaseDistribution.installed_by_distutils   s-     **||M*2244r-   c                p    U R                   nU(       d  g[        R                  " U5      R                  S:H  $ )zWhether this distribution is installed as an egg.

This usually indicates the distribution was installed by (older versions
of) easy_install.
Fz.egg)rg   rB   rC   suffixr(   rg   s     r)   installed_as_egg!BaseDistribution.installed_as_egg   s/     == ||H%,,66r-   c                    U R                   nU(       d  gUR                  S5      (       d  g[        R                  " U5      R	                  5       $ )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rz   endswithrB   rC   is_dirr~   s     r)   "installed_with_setuptools_egg_info3BaseDistribution.installed_with_setuptools_egg_info   sA     **%%k22||M*1133r-   c                    U R                   nU(       d  gUR                  S5      (       d  g[        R                  " U5      R	                  5       $ )a9  Whether 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-infor   r~   s     r)   installed_with_dist_info)BaseDistribution.installed_with_dist_info   sA     **%%l33||M*1133r-   c                    [        5       er$   r%   r'   s    r)   canonical_nameBaseDistribution.canonical_name  r,   r-   c                    [        5       er$   r%   r'   s    r)   versionBaseDistribution.version  r,   r-   c                    [        5       er$   r%   r'   s    r)   rf   BaseDistribution.raw_version  r,   r-   c                :    U R                   R                  SS5      $ )zConvert a project name to its setuptools-compatible filename.

This is a copy of ``pkg_resources.to_filename()`` for compatibility.
-_)re   replacer'   s    r)   setuptools_filename$BaseDistribution.setuptools_filename  s     }}$$S#..r-   c                     U R                  [        5      n [        R                  " U5      $ ! [         a     gf = f! [
        [        R                  [        4 a0  n[        R                  S[        U R                  U5         SnAgSnAff = f)zObtain a DirectUrl from this distribution.

Returns None if the distribution has no `direct_url.json` metadata,
or if `direct_url.json` is invalid.
NzError parsing %s for %s: %s)	read_textr   FileNotFoundErrorr   	from_jsonUnicodeDecodeErrorjsonJSONDecodeErrorr   loggerwarningr   )r(   contentes      r)   rp   BaseDistribution.direct_url  s    	nn%=>G	&&w// ! 		
   $
 	
 NN-(##	 	s!   . > 
;;B&BBc                     U R                  S5      nUR	                  5        H  nUR                  5       nU(       d  M  Us  $    g! [        [        [        4 a     gf = f)N	INSTALLER )r   OSError
ValueErrorr   
splitlinesstrip)r(   installer_textlinecleaned_lines       r)   	installerBaseDistribution.installer9  sa    	!^^K8N #--/D::<L|## 0  %67 		s   A AAc                $    U R                  S5      $ )N	REQUESTED)r}   r'   s    r)   	requestedBaseDistribution.requestedE  s    ||K((r-   c                ,    [        U R                  5      $ r$   )boolrt   r'   s    r)   editableBaseDistribution.editableI  s    D2233r-   c                H    U R                   c  g[        U R                   5      $ )zlIf distribution is installed in the current virtual environment.

Always True if we're not in a virtualenv.
F)rw   r   r'   s    r)   localBaseDistribution.localM  s$     ""*//00r-   c                |    U R                   b  [        c  gU R                   R                  [        [        5      5      $ NF)rw   r   
startswithr   r'   s    r)   in_usersiteBaseDistribution.in_usersiteW  s2    ""*i.?&&11.2KLLr-   c                |    U R                   b  [        c  gU R                   R                  [        [        5      5      $ r   )rw   r   r   r   r'   s    r)   in_site_packages!BaseDistribution.in_site_packages]  s2    ""*m.C&&11.2OPPr-   c                    [        5       e)z7Check whether an entry in the info directory is a file.r%   r(   paths     r)   r}   BaseDistribution.is_filec  r,   r-   c                    [        5       e)zFind 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'   s    r)   iter_distutils_script_names,BaseDistribution.iter_distutils_script_namesg  rV   r-   c                    [        5       e)zRead 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   s     r)   r   BaseDistribution.read_texto       "##r-   c                    [        5       er$   r%   r'   s    r)   iter_entry_points"BaseDistribution.iter_entry_pointsx      !##r-   c                    [        5       er$   r%   r'   s    r)   _metadata_implBaseDistribution._metadata_impl{  r   r-   c                H    U R                  5       nU R                  U5        U$ )zMetadata 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(   metadatas     r)   r   BaseDistribution.metadata~  s%     &&(##H-r-   c                ,    [        U R                  5      $ )zPEP 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.
)r   r   r'   s    r)   metadata_dictBaseDistribution.metadata_dict  s     4==))r-   c                8    U R                   R                  S5      $ )zDValue of "Metadata-Version:" in distribution metadata, if available.zMetadata-Version)r   getr'   s    r)   metadata_version!BaseDistribution.metadata_version  s     }}  !344r-   c                N    U R                   R                  SU R                  5      $ )z*Value of "Name:" in distribution metadata.Name)r   r   r   r'   s    r)   re   BaseDistribution.raw_name  s!    
 }}  )<)<==r-   c                   U R                   R                  S5      nUc
  [        5       $  [        [        U5      5      nU$ ! [         a6  nSn[
        R                  X@R                  U5        [        5       s SnA$ SnAff = f)zValue of "Requires-Python:" in distribution metadata.

If the key does not exist or contains an invalid value, an empty
SpecifierSet should be returned.
zRequires-PythonNz-Package %r has an invalid Requires-Python: %s)r   r   r   r7   r   r   r   re   )r(   r/   specr   messages        r)   requires_python BaseDistribution.requires_python  sq     !!"34=>!	"E
+D
 	   	"EGNN7MM15>!	"s   A   
B 
+A;5B ;B r4   c                    [        5       e)zDependencies of this distribution.

For modern .dist-info distributions, this is the collection of
"Requires-Dist:" entries in distribution metadata.
r%   )r(   extrass     r)   iter_dependencies"BaseDistribution.iter_dependencies  rV   r-   c                :    U R                   R                  S/ 5      $ )zRaw Requires-Dist metadata.Requires-Dist)r   get_allr'   s    r)   iter_raw_dependencies&BaseDistribution.iter_raw_dependencies  s    }}$$_b99r-   c                    [        5       e)a:  Extras 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'   s    r)   iter_provided_extras%BaseDistribution.iter_provided_extras  s     "##r-   c                     U R                  S5      nS [        R                  " UR	                  5       5       5       $ ! [         a     g f = f)NRECORDc              3  f   #    U  H'  n[        [        R                  " US    5      5      v   M)     g7f)r   NrA   ).0rows     r)   	<genexpr>FBaseDistribution._iter_declared_entries_from_record.<locals>.<genexpr>  s'     S5RcGLLQ())5Rs   /1)r   r   csvreaderr   )r(   texts     r)   "_iter_declared_entries_from_record3BaseDistribution._iter_declared_entries_from_record  sG    	>>(+D TSZZ@Q5RSS ! 		s   > 
A
Ac                b  ^  U R                  S5      nS UR                  SS9 5       nU R                  nU R                  nUb  Uc  U$  [
        R                  " U5      R                  U5      mTR                  (       d  U$ U4S jU 5       $ ! [         a     g f = f! [         a    Us $ f = f)Nzinstalled-files.txtc              3  6   #    U  H  o(       d  M  Uv   M     g 7fr$   r4   )r   ps     r)   r   FBaseDistribution._iter_declared_entries_from_legacy.<locals>.<genexpr>  s     A;qq;s   
	F)keependsc              3     >#    U  H9  n[        [        R                  " U5      R                  TR                  5      v   M;     g 7fr$   )rF   rB   rC   parts)r   r  info_rels     r)   r   r    s4      
 *',,q/*?*?PPs   AA)
r   r   r   rg   rz   rB   rC   relative_tor   r
  )r(   r  pathsrootrE   r  s        @r)   "_iter_declared_entries_from_legacy3BaseDistribution._iter_declared_entries_from_legacy  s    	>>"78D BDOOUO;A}}!!<4<L	||D)55d;H ~~L

 	
 ! 		  	L	s#   B %B 
BBB.-B.c                P    U R                  5       =(       d    U R                  5       $ )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'   s    r)   iter_declared_entries&BaseDistribution.iter_declared_entries  s&     335 9668	
r-   c              #    #     U R                  S5      nS=p#UR                  5        H  nUR                  5       nU(       a  UR	                  S5      (       a  M2  UR	                  S5      (       a;  UR                  S5      (       a%  UR                  S5      R                  S5      u  p%nM  [        XBUS	9v   M     g! [         a     gf = f7f)
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.
zrequires.txtNr   #[]z[]:)rJ   rK   rL   )r   r   r   r   r   r   	partitionrH   )r(   r   rK   rL   r   r   s         r)   _iter_requires_txt_entries+BaseDistribution._iter_requires_txt_entries  s     	nn^4G &&(D::<D4??3//s##c(:(:#'::d#3#=#=c#B &DfMM ) ! 		s(   CB< B'C<
C	CC		Cc              #     #    S1nU R                  5        H4  n[        UR                  5      nX1;   a  M  UR                  U5        Uv   M6     g7f)z'Get extras from the egg-info directory.r   N)r  r   rK   add)r(   known_extrasrD   rK   s       r)   _iter_egg_info_extras&BaseDistribution._iter_egg_info_extras  sI     t446E%ekk2E$U#K 7s   AAc              #  l  #    U R                  5        H  n[        UR                  5      nU(       a%  UR                  (       a  SUR                   SU S3nO.U(       a  SU S3nO UR                  (       a  UR                  nOSnU(       a  UR                   SU 3v   M  UR                  v   M     g7f)aA  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  r   rK   rL   rJ   )r(   rD   rK   rL   s       r)   _iter_egg_info_dependencies,BaseDistribution._iter_egg_info_dependencies  s      446E%ekk2EU\\N*:5'C%eWA.**+3vh77''' 7s   B2B4c                    UR                  S5      (       d  U R                  5        H  nX!S'   M	     UR                  S5      (       d  U R                  5        H  nX1S'   M	     gg)z6Add egg-info requires.txt information to the metadata.r   zProvides-ExtraN)r   r$  r  )r(   r   deprK   s       r)   r   'BaseDistribution._add_egg_info_requires9  sa    00779,/) : 011335-2)* 6 2r-   N)rS   r7   r6   rO   )rX   bytesrY   r7   rZ   r7   r6   rO   )r^   Wheelr*   r7   r6   rO   r5   )r6   z
str | None)r6   r   )r6   r   )r6   r   )r6   zDirectUrl | None)r   InfoPathr6   r   )r6   zIterator[str])r   r+  r6   r7   )r6   zIterable[BaseEntryPoint])r6   email.message.Message)r6   zdict[str, Any])r6   r   )r4   )r   zCollection[str]r6   zIterable[Requirement])r6   zIterable[str])r6   zIterable[NormalizedName])r6   zIterator[str] | None)r6   zIterator[RequiresEntry])r   r,  r6   None)5r8   r9   r:   r;   classmethodrT   r[   r_   rh   rk   r<   rg   rt   rw   rz   r   r   r   r   r   r   rf   r   rp   r   r   r   r   r   r   r}   r   r   r   r   	functoolscached_propertyr   r   r   re   r   r   r   r   r  r  r  r  r  r$  r   r=   r4   r-   r)   rO   rO   ^   s   $ $ $ $ $ 	$
 
$ $" $ $G5 $ $  * 
$ 
$ $ $ 
5 
5 7 7 4 4" 4 4 $ $ $ $ $ $ / /  2 	 	 ) ) 4 4 1 1 M M
 Q Q
$$$$$ 
 
 * * 5 5 > >  $$:
$T
*
 N2(83r-   rO   c                      \ rS rSrSr\SS j5       r\SS j5       rSS jrSS jr	SS jr
S\SS	S	4           SS
 jjrSrg)BaseEnvironmentiC  z6An environment containing distributions to introspect.c                    [        5       er$   r%   )rR   s    r)   defaultBaseEnvironment.defaultF  r,   r-   c                    [        5       er$   r%   )rR   r  s     r)   
from_pathsBaseEnvironment.from_pathsJ  r,   r-   c                    [        5       e)zGiven a requirement name, return the installed distributions.

The name may not be normalized. The implementation must canonicalize
it for lookup.
r%   )r(   r*   s     r)   get_distribution BaseEnvironment.get_distributionN  rV   r-   c                    [        5       e)zIterate 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'   s    r)   _iter_distributions#BaseEnvironment._iter_distributionsV  r   r-   c              #    #    U R                  5        Hi  n[        R                  " SUR                  [        R                  S9nU(       d-  [
        R                  SUR                  UR                  5        Me  Uv   Mk     g7f)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matchr   
IGNORECASEr   r   rg   )r(   distproject_name_valids      r)   iter_all_distributions&BaseEnvironment.iter_all_distributions_  sj     ,,.D
 "$<##mm"
 &;''MM
 J# /s   A?BTFc                   ^ U R                  5       nU(       a	  S U 5       nU(       d	  S U 5       nU(       a	  S U 5       nU(       a	  S U 5       nU4S jU 5       $ )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.
c              3  J   #    U  H  oR                   (       d  M  Uv   M     g 7fr$   )r   r   ds     r)   r   ?BaseEnvironment.iter_installed_distributions.<locals>.<genexpr>  s     +R77!!R   #	#c              3  J   #    U  H  oR                   (       a  M  Uv   M     g 7fr$   r   rJ  s     r)   r   rL    s     2Rzz!!RrM  c              3  J   #    U  H  oR                   (       d  M  Uv   M     g 7fr$   rO  rJ  s     r)   r   rL    s     .R::!!RrM  c              3  J   #    U  H  oR                   (       d  M  Uv   M     g 7fr$   )r   rJ  s     r)   r   rL    s     1R==!!RrM  c              3  J   >#    U  H  oR                   T;  d  M  Uv   M     g 7fr$   )r   )r   rK  skips     r)   r   rL    s     >2a!1!1!=2s   #	#)rF  )r(   
local_onlyrS  include_editableseditables_only	user_onlyits     `    r)   iter_installed_distributions,BaseEnvironment.iter_installed_distributionst  sR    0 ((*+R+B 2R2B.R.B1R1B>2>>r-   r4   N)r6   r2  )r  zlist[str] | Noner6   r2  )r*   r7   r6   zBaseDistribution | None)r6   Iterator[BaseDistribution])rT  r   rS  zContainer[str]rU  r   rV  r   rW  r   r6   r[  )r8   r9   r:   r;   __doc__r.  r4  r7  r:  r=  rF  r   rY  r=   r4   r-   r)   r2  r2  C  s    @$ $ $ $$$.  *"&$!?!? !?  	!?
 !? !? 
$!? !?r-   r2  c                  *    \ rS rSr% S\S'   SS jrSrg)r*  i  r7   rg   c                    [        5       er$   r%   r'   s    r)   
as_zipfileWheel.as_zipfile  r   r-   r4   Nr6   zzipfile.ZipFile)r8   r9   r:   r;   rM   r_  r=   r4   r-   r)   r*  r*    s    M$r-   r*  c                  (    \ rS rSrSS jrSS jrSrg)FilesystemWheeli  c                    Xl         g r$   rg   r   s     r)   __init__FilesystemWheel.__init__  s     r-   c                @    [         R                  " U R                  SS9$ NT)
allowZip64)zipfileZipFilerg   r'   s    r)   r_  FilesystemWheel.as_zipfile  s    t}}>>r-   re  N)rg   r7   r6   r-  ra  r8   r9   r:   r;   rf  r_  r=   r4   r-   r)   rc  rc    s    !?r-   rc  c                  (    \ rS rSrSS jrSS jrSrg)MemoryWheeli  c                    Xl         X l        g r$   rg   stream)r(   rg   rs  s      r)   rf  MemoryWheel.__init__  s     r-   c                @    [         R                  " U R                  SS9$ ri  )rk  rl  rs  r'   s    r)   r_  MemoryWheel.as_zipfile  s    t{{t<<r-   rr  N)rg   r7   rs  z	IO[bytes]r6   r-  ra  rn  r4   r-   r)   rp  rp    s    =r-   rp  )rD   tuple[str, ...]rE   rw  r6   r7   )B
__future__r   r   email.messageemailr/  r   loggingrB   rA  rk  collections.abcr   r   r   r   typingr   r	   r
   r   r   "pip._vendor.packaging.requirementsr    pip._vendor.packaging.specifiersr   r   pip._vendor.packaging.utilsr   r   pip._vendor.packaging.versionr   pip._internal.exceptionsr   pip._internal.locationsr   r   pip._internal.models.direct_urlr   r   r   pip._internal.utils.compatr   pip._internal.utils.egg_linkr   pip._internal.utils.miscr   r   pip._internal.utils.urlsr   _jsonr   r7   PurePathr+  	getLoggerr8   r   r!   rF   rH   rO   r2  r*  rc  rp  r4   r-   r)   <module>r     s    " 
      	  E E  ; K I 1 6 < 
 3 D = 0 g&&&'			8	$$X $,,
, 	,<J b3x b3JR? R?j$H $?e ?=% =r-   