
    'j*d                       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  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+J,r,  S SK-J.r.  SSK/J0r0  1 Skr1\2\Rf                  -  r4\Rj                  " \65      r7 " S S\5      r8      S!S jr9 " S S\5      r: " S S\5      r; " S S5      r< " S S\5      r= " S S\=5      r> " S S \=5      r?g)"    )annotationsN)
Collection	ContainerIterableIterator)IOAny
NamedTupleProtocol)Requirement)InvalidSpecifierSpecifierSet)NormalizedNamecanonicalize_name)Version)NoneMetadataError)site_packages	user_site)DIRECT_URL_METADATA_NAME	DirectUrlDirectUrlValidationError)egg_link_path_from_sys_path)is_localnormalize_path)url_to_path   )msg_to_json>   pythonwsgirefargparsec                  P    \ rS rSr\SS j5       r\SS j5       r\SS j5       rSrg)BaseEntryPoint2   c                    [        5       eNNotImplementedErrorselfs    S/var/www/html/KUNJ/venv/lib/python3.13/site-packages/pip/_internal/metadata/base.pynameBaseEntryPoint.name3       !##    c                    [        5       er%   r&   r(   s    r*   valueBaseEntryPoint.value7   r-   r.   c                    [        5       er%   r&   r(   s    r*   groupBaseEntryPoint.group;   r-   r.    Nreturnstr)	__name__
__module____qualname____firstlineno__propertyr+   r0   r3   __static_attributes__r5   r.   r*   r"   r"   2   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   r8   pathlibPath)entryinfos     r*   _convert_installed_files_pathrG   @   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)RequiresEntry^   r8   requirementextramarkerr5   N)r9   r:   r;   r<   __annotations__r>   r5   r.   r*   rI   rI   ^   s    JKr.   rI   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\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$\R                  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BaseDistributiond   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_directorye        "##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&   )rS   metadata_contentsfilenameproject_names       r*   from_metadata_file_contents,BaseDistribution.from_metadata_file_contentsm   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&   )rS   wheelr+   s      r*   
from_wheelBaseDistribution.from_wheel        "##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$ )Nrd   )rf   rg   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*   rh   BaseDistribution.location   rb   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   rf   rh   )r)   rq   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)r{   rC   rD   is_filer)   r{   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)rh   rC   rD   suffixr)   rh   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r{   endswithrC   rD   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*   rg   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.
-_)rf   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*   rq   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.installer>  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.requestedJ  s    ||K((r.   c                ,    [        U R                  5      $ r%   )boolru   r(   s    r*   editableBaseDistribution.editableN  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)rx   r   r(   s    r*   localBaseDistribution.localR  s$     ""*//00r.   c                |    U R                   b  [        c  gU R                   R                  [        [        5      5      $ NF)rx   r   
startswithr   r(   s    r*   in_usersiteBaseDistribution.in_usersite\  s2    ""*i.?&&11.2KLLr.   c                |    U R                   b  [        c  gU R                   R                  [        [        5      5      $ r   )rx   r   r   r   r(   s    r*   in_site_packages!BaseDistribution.in_site_packagesb  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_fileh  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_namesl  rW   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_textt       "##r.   c                    [        5       er%   r&   r(   s    r*   iter_entry_points"BaseDistribution.iter_entry_points}      !##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*   rf   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   r8   r   r   r   rf   )r)   r0   specr   messages        r*   requires_python BaseDistribution.requires_python  sq     !!"34=>!	"E
+D
 	   	"EGNN7MM15>!	"s   A   
B 
+A;5B ;B r5   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  rW   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   NrB   ).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%   r5   )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%   )rG   rC   rD   parts)r   r  info_rels     r*   r   r    s4      
 *',,q/*?*?PPs   AA)
r   r   r   rh   r{   rC   rD   relative_tor   r  )r)   r  pathsrootrF   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[]:)rK   rL   rM   )r   r   r   r   r   r   	partitionrI   )r)   r   rL   rM   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   rL   add)r)   known_extrasrE   rL   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   rL   rM   rK   )r)   rE   rL   rM   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   deprL   s       r*   r   'BaseDistribution._add_egg_info_requires>  sa    00779,/) : 011335-2)* 6 2r.   N)rT   r8   r7   rP   )rY   bytesrZ   r8   r[   r8   r7   rP   )r_   Wheelr+   r8   r7   rP   r6   )r7   z
str | None)r7   r   )r7   r   )r7   r   )r7   zDirectUrl | None)r   InfoPathr7   r   )r7   zIterator[str])r   r,  r7   r8   )r7   zIterable[BaseEntryPoint])r7   email.message.Message)r7   zdict[str, Any])r7   r   )r5   )r   zCollection[str]r7   zIterable[Requirement])r7   zIterable[str])r7   zIterable[NormalizedName])r7   zIterator[str] | None)r7   zIterator[RequiresEntry])r   r-  r7   None)5r9   r:   r;   r<   classmethodrU   r\   r`   ri   rl   r=   rh   	functoolscached_propertyru   rx   r{   r   r   r   r   r   r   rg   r   rq   r   r   r   r   r   r   r~   r   r   r   r   r   r   r   rf   r   r   r   r   r  r  r  r  r   r%  r   r>   r5   r.   r*   rP   rP   d   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.   rP   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)BaseEnvironmentiH  z6An environment containing distributions to introspect.c                    [        5       er%   r&   )rS   s    r*   defaultBaseEnvironment.defaultK  r-   r.   c                    [        5       er%   r&   )rS   r  s     r*   
from_pathsBaseEnvironment.from_pathsO  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_distributionS  rW   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_distributions[  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   rh   )r)   distproject_name_valids      r*   iter_all_distributions&BaseEnvironment.iter_all_distributionsd  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   rK  s     r*   r   rM    s     2Rzz!!RrN  c              3  J   #    U  H  oR                   (       d  M  Uv   M     g 7fr%   rP  rK  s     r*   r   rM    s     .R::!!RrN  c              3  J   #    U  H  oR                   (       d  M  Uv   M     g 7fr%   )r   rK  s     r*   r   rM    s     1R==!!RrN  c              3  J   >#    U  H  oR                   T;  d  M  Uv   M     g 7fr%   )r   )r   rL  skips     r*   r   rM    s     >2a!1!1!=2s   #	#)rG  )r)   
local_onlyrT  include_editableseditables_only	user_onlyits     `    r*   iter_installed_distributions,BaseEnvironment.iter_installed_distributionsy  sR    0 ((*+R+B 2R2B.R.B1R1B>2>>r.   r5   N)r7   r3  )r  zlist[str] | Noner7   r3  )r+   r8   r7   zBaseDistribution | None)r7   Iterator[BaseDistribution])rU  r   rT  zContainer[str]rV  r   rW  r   rX  r   r7   r\  )r9   r:   r;   r<   __doc__r/  r5  r8  r;  r>  rG  stdlib_pkgsrZ  r>   r5   r.   r*   r3  r3  H  s    @$ $ $ $$$.  *"&$!?!? !?  	!?
 !? !? 
$!? !?r.   r3  c                  *    \ rS rSr% S\S'   SS jrSrg)r+  i  r8   rh   c                    [        5       er%   r&   r(   s    r*   
as_zipfileWheel.as_zipfile  r   r.   r5   Nr7   zzipfile.ZipFile)r9   r:   r;   r<   rN   ra  r>   r5   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%   rh   r   s     r*   __init__FilesystemWheel.__init__  s     r.   c                @    [         R                  " U R                  SS9$ NT)
allowZip64)zipfileZipFilerh   r(   s    r*   ra  FilesystemWheel.as_zipfile  s    t}}>>r.   rg  N)rh   r8   r7   r.  rc  r9   r:   r;   r<   rh  ra  r>   r5   r.   r*   re  re    s    !?r.   re  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%   rh   stream)r)   rh   ru  s      r*   rh  MemoryWheel.__init__  s     r.   c                @    [         R                  " U R                  SS9$ rk  )rm  rn  ru  r(   s    r*   ra  MemoryWheel.as_zipfile  s    t{{t<<r.   rt  N)rh   r8   ru  z	IO[bytes]r7   r.  rc  rp  r5   r.   r*   rr  rr    s    =r.   rr  )rE   tuple[str, ...]rF   ry  r7   r8   )@
__future__r   r   email.messageemailr0  r   loggingrC   rB  rm  collections.abcr   r   r   r   typingr   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.egg_linkr   pip._internal.utils.miscr   r   pip._internal.utils.urlsr   _jsonr   r^  r8   PurePathr,  	getLoggerr9   r   r"   rG   rI   rP   r3  r+  re  rr  r5   r.   r*   <module>r     s    " 
      	  E E  ; K I 1 6 < 
 E = 0  0 !!!			8	$$X $,,
, 	,<J a3x a3HR? R?j$H $?e ?=% =r.   