U
|
G=®dÁ§ ã G @ s d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
|
Z
|
ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlm Z z ddl Z W n e k
|
r ddl Z Y nX ze W n e!k
|
r* e"Z Y nX ddl#m$Z$ ddl%m&Z&m'Z' ddlm(Z( z ddlm)Z)m*Z*m+Z+ d Z,W n e k
|
r d
|
Z,Y nX dd lm-Z. dd l/m0Z0m1Z1 zddl2m3Z4 e4j5 W n e k
|
rØ dZ4Y nX dd l#m6Z6 ddl#m7Z7 e8d e8d e8d e8d e9Z:dej; k r0dk r<n ne<de$j=rLdZ>dZ?dZ@dZAdZBdZCdZDdZEdZFdZGdZHdZIdZJdZKdZLdZMdZNdZOdZPG dd deQZRdd ZSi ZTdd ZUd d ZVd d ZWd d! ZXd"d# ZYd$d% ZZd&d' Z[d(d) Z\Z]d*d+ Z^d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKddLddMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpgGZ_G dqdG dGe`ZaG drdH dHeaZbG dsdt dtebZcG dudI dIeaZdG dvdJ dJeaZei Zfdwjgej; ZhdxZidyZjdzZkdZld{Zmd|dk Znd}d. Zog fd~dZpdd Zqdd Zre sd¡Zte sd
¡ZuerZvddP Zwdd- ZxexZydd/ Zzdd0 Z{dÿdd1Z|dd2 Z}G dd^ d^Z~G dd_ d_e~ZG ddB dBZG dd deZG ddA dAZeZG ddK dKe<Z
G ddC dCZdd@ ZddM ZddN ZddS ZddT ZddU Zd ddVZG dde deZenee dd ZG ddf dfeZG ddg dgeZe ¡ G d dc dceZe ZG d¡d¢ d¢eZG d£d¤ d¤eZG d¥dh dheZene
|
je G d¦d` d`eZG d§da daeZG d¨db dbeZeUd©i dª d«di Zdd¬d=Zddd®Zee
|
je dd¯d°Z eee d±d² Z¡dd³d´Z¢dµd¶ Z£G d·d¸ d¸Z¤d¹dº Z¥d»d¼ Z¦d½d¾ Z§d¿dÀ Z¨eej©e¢ eªe4dÁr¦ee4j«e¢ eUd©i d eUd©i dà dÄdj Z¬dÅdÆ ZdÇdÈ Z®dÉd: Z¯ddÊdlZ°dËdÌ Z±e¬ej©e± e¬e
|
je± eªe4dÁr"e¬e4j«e± dÍdÎ Z²e¬ee² dÏdX Z³dÐdÑ Z´i fdÒdÓZµdÔdÕ Z¶dÖd× Z·dØdÙ Z¸dÚdQ Z¹e sdÛ¡jºZ»e sdÜej¼ej½B ¡jºZ¾G dÝdF dFZ¿dÞdß ZÀG dàdD dDZÁG dádâ dâeÁZÂG dãdä däeÁZÃeÁeÂeÃdåZÄdædç ZÅdèdL ZÆG dédê dêe7jÇjÈZÉG dëdE dEe7jÇjÊZÊdìdí ZËdîdï ZÌdðdW ZÍdñdò ZÎdódR ZÏdôdõ ZÐe jÑdöeRd d÷ dødù ZÒeÒeÓ fdúdûZÔeÒdüdý ZÕG dþdn dneÖZ×dS ( aZ
|
Package resource API
|
--------------------
|
|
A resource is a logical file contained within a package, or a logical
|
subdirectory thereof. The package resource API expects resource names
|
to have their path parts separated with ``/``, *not* whatever the local
|
path separator is. Do not use os.path operations to manipulate resource
|
names being passed into the API.
|
|
The package resource API is designed to work with normal filesystem packages,
|
.egg files, and unpacked .egg files. It can also work in a limited way with
|
.zip files and with custom PEP 302 loaders that support the ``get_data()``
|
method.
|
é )Úabsolute_importN)Ú get_importer)Úsix)ÚmapÚfilter)Úutime)ÚmkdirÚrenameÚunlinkTF)Úopen)ÚisdirÚsplit)Úappdirs)Ú packagingz&pkg_resources.extern.packaging.versionz)pkg_resources.extern.packaging.specifiersz+pkg_resources.extern.packaging.requirementsz&pkg_resources.extern.packaging.markers)é r )r é z Python 3.5 or later is requiredc @ s e Zd ZdZdS )Ú PEP440Warningza
|
Used when there is an issue with a version or specifier not complying with
|
PEP 440.
|
N©Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__© r r úMD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pkg_resources/__init__.pyr w s r c C s8 zt j | ¡W S t jjk
|
r2 t j | ¡ Y S X d S ©N)r ÚversionÚVersionÚInvalidVersionÚ LegacyVersion)Úvr r r Ú parse_version~ s r c K s" t |¡ t t || ¡¡ d S r )ÚglobalsÚupdateÚ _state_varsÚdictÚfromkeys)ÚvartypeÚkwr r r Ú_declare_state s r( c C s8 i } t }t ¡ D ] \}}|d| || | |< q| S )NÚ_sget_)r! r# Úitems©ÚstateÚgÚkr r r r Ú __getstate__ s
|
r/ c C s8 t }| ¡ D ]$\}}|dt| ||| | q| S )NÚ_sset_)r! r* r# r+ r r r Ú __setstate__ s r1 c C s | ¡ S r )Úcopy©Úvalr r r Ú
|
_sget_dict s r5 c C s | ¡ | |¡ d S r )Úclearr" ©ÚkeyÚobr, r r r Ú
|
_sset_dict s r: c C s | ¡ S r )r/ r3 r r r Ú _sget_object¥ s r; c C s | |¡ d S r )r1 r7 r r r Ú _sset_object© s r< c G s d S r r ©Úargsr r r Ú<lambda> ó r? c C sb t } t | ¡}|dk r^tjdkr^z&dd t dd
¡| d¡f } W n tk
|
r\ Y nX | S )aQ Return this platform's maximum compatible version.
|
|
distutils.util.get_platform() normally reports the minimum version
|
of macOS that would be required to *use* extensions produced by
|
distutils. But what we want when checking compatibility is to know the
|
version of macOS that we are *running*. To allow usage of packages that
|
explicitly require a newer version of macOS, we must also know the
|
current version of the OS.
|
|
If this condition occurs for any other platform with a version in its
|
platform strings, this function should be extended accordingly.
|
NÚdarwinz macosx-%s-%sÚ.é r ) Úget_build_platformÚmacosVersionStringÚmatchÚsysÚplatformÚjoinÚ _macos_versÚgroupÚ
|
ValueError)ÚplatÚmr r r Úget_supported_platform° s
|
&rO ÚrequireÚ
|
run_scriptÚ get_providerÚget_distributionÚload_entry_pointÚ get_entry_mapÚget_entry_infoÚiter_entry_pointsÚresource_stringÚresource_streamÚresource_filenameÚresource_listdirÚresource_existsÚresource_isdirÚdeclare_namespaceÚ working_setÚadd_activation_listenerÚfind_distributionsÚset_extraction_pathÚcleanup_resourcesÚget_default_cacheÚ EnvironmentÚ
|
WorkingSetÚResourceManagerÚ DistributionÚ RequirementÚ
|
EntryPointÚResolutionErrorÚVersionConflictÚDistributionNotFoundÚ UnknownExtraÚExtractionErrorÚparse_requirementsÚ safe_nameÚ safe_versionÚ get_platformÚcompatible_platformsÚ yield_linesÚsplit_sectionsÚ
|
safe_extraÚ to_filenameÚinvalid_markerÚevaluate_markerÚensure_directoryÚnormalize_pathÚEGG_DISTÚ BINARY_DISTÚ SOURCE_DISTÚ CHECKOUT_DISTÚ DEVELOP_DISTÚIMetadataProviderÚIResourceProviderÚ FileMetadataÚ PathMetadataÚ EggMetadataÚ EmptyProviderÚempty_providerÚ NullProviderÚ EggProviderÚDefaultProviderÚ ZipProviderÚregister_finderÚregister_namespace_handlerÚregister_loader_typeÚfixup_namespace_packagesr Ú PkgResourcesDeprecationWarningÚrun_mainÚAvailableDistributionsc @ s e Zd ZdZdd ZdS )rk z.Abstract base for dependency resolution errorsc C s | j jt| j S r )Ú __class__r Úreprr> ©Úselfr r r Ú__repr__ý s zResolutionError.__repr__N)r r r r r r r r r rk ú s c @ s< e Zd ZdZdZedd Zedd Zdd Zd d
|
Z d S ) rl zª
|
An already-installed version conflicts with the requested version.
|
|
Should be initialized with the installed Distribution and the requested
|
Requirement.
|
z3{self.dist} is installed but {self.req} is requiredc C s
|
| j d S ©Nr r= r r r r Údist s zVersionConflict.distc C s
|
| j d S ©Né r= r r r r Úreq s zVersionConflict.reqc C s | j jf t S r ©Ú _templateÚformatÚlocalsr r r r Úreport s zVersionConflict.reportc C s |s| S | j |f }t| S )zt
|
If required_by is non-empty, return a version of self that is a
|
ContextualVersionConflict.
|
)r> ÚContextualVersionConflict)r Ú required_byr> r r r Ú with_context s z VersionConflict.with_contextN)
|
r r r r r Úpropertyr r r¢ r¥ r r r r rl s
|
|
c @ s& e Zd ZdZejd Zedd ZdS )r£ z
|
A VersionConflict that accepts a third parameter, the set of the
|
requirements that required the installed Distribution.
|
z by {self.required_by}c C s
|
| j d S )NrC r= r r r r r¤ ) s z%ContextualVersionConflict.required_byN)r r r r rl r r¦ r¤ r r r r r£ ! s
|
r£ c @ sH e Zd ZdZdZedd Zedd Zedd Zd d
|
Z d d Z
|
d S )rm z&A requested distribution was not foundzSThe '{self.req}' distribution was not found and is required by {self.requirers_str}c C s
|
| j d S r r= r r r r r 4 s zDistributionNotFound.reqc C s
|
| j d S r r= r r r r Ú requirers8 s z DistributionNotFound.requirersc C s | j s
|
dS d | j ¡S )Nzthe applicationz, )r§ rI r r r r Ú requirers_str< s z"DistributionNotFound.requirers_strc C s | j jf t S r r r r r r r¢ B s zDistributionNotFound.reportc C s | ¡ S r )r¢ r r r r Ú__str__E s z DistributionNotFound.__str__N) r r r r r r¦ r r§ r¨ r¢ r© r r r r rm . s
|
|
|
c @ s e Zd ZdZdS )rn z>Distribution doesn't have an "extra feature" of the given nameNr r r r r rn I s z{}.{}r rC r éÿÿÿÿc C s |t | < dS )a Register `provider_factory` to make providers for `loader_type`
|
|
`loader_type` is the type or class of a PEP 302 ``module.__loader__``,
|
and `provider_factory` is a function that, passed a *module* object,
|
returns an ``IResourceProvider`` for that module.
|
N)Ú_provider_factories)Ú loader_typeÚprovider_factoryr r r r W s c C st t | tr$t | ¡p"tt| d S ztj| }W n& tk
|
rX t | tj| }Y nX t
|
|dd}t t ||S )z?Return an IResourceProvider for the named module or requirementr Ú
|
__loader__N) Ú
|
isinstanceri r_ ÚfindrP ÚstrrG ÚmodulesÚKeyErrorÚ
|
__import__ÚgetattrÚ _find_adapterr« )Ú moduleOrReqÚmoduleÚloaderr r r rR a s
|
c C sd | s\t ¡ d }|dkrLd}tj |¡rLttdrLt |¡}d|krL|d }| | d¡¡ | d S )Nr Ú z0/System/Library/CoreServices/SystemVersion.plistÚ readPlistÚProductVersionrB )
|
rH Úmac_verÚosÚpathÚexistsÚhasattrÚplistlibr» Úappendr )Ú_cacher ÚplistÚ plist_contentr r r rJ n s
|
|
rJ c C s ddd | | ¡S )NÚppc)ÚPowerPCÚPower_Macintosh)Úget)Úmachiner r r Ú _macos_arch~ s rÌ c C s~ ddl m} | }tjdkrz| d¡szz>t }t ¡ d dd¡}dt |d t |d t
|
|f W S t k
|
rx Y nX |S )
|
zÁReturn this platform's string for platform-specific distributions
|
|
XXX Currently this is the same as ``distutils.util.get_platform()``, but it
|
needs some hacks for Linux and macOS.
|
r )rs rA zmacosx-é ú Ú_zmacosx-%d.%d-%sr ) Ú sysconfigrs rG rH Ú
|
startswithrJ r¾ ÚunameÚreplaceÚintrÌ rL )rs rM r rË r r r rD s
|
|
þrD zmacosx-(\d+)\.(\d+)-(.*)z darwin-(\d+)\.(\d+)\.(\d+)-(.*)c C sè | dks|dks| |kr dS t |¡}|rät | ¡}|st | ¡}|rt| d¡}d| d¡| d¡f }|dkr||dks|dkr|d krdS d
|
S | d¡| d¡ks¼| d ¡| d ¡krÀd
|
S t| d¡t| d¡kràd
|
S dS d
|
S ) zÛCan code for the `provided` platform run on the `required` platform?
|
|
Returns true if either platform is ``None``, or the platforms are equal.
|
|
XXX Needs compatibility checks for Linux and other unixy OSes.
|
NTr z%s.%srC é z10.3é z10.4Fr )rE rF ÚdarwinVersionStringrÔ rK )ÚprovidedÚrequiredÚreqMacÚprovMacÚ
|
provDarwinÚdversionÚ macosversionr r r rt s2
|
|
|
ÿÿÿ c C s< t d¡j}|d }| ¡ ||d< t| d ||¡ dS )z@Locate distribution `dist_spec` and run its `script_name` scriptr r r N©rG Ú _getframeÚ f_globalsr6 rP rQ )Z dist_specÚ script_nameÚnsÚnamer r r rQ Î s
|
c C s@ t | tjrt | ¡} t | tr(t| } t | ts<td| | S )z@Return a current distribution object for a Requirement or stringz-Expected string, Requirement, or Distribution)r¯ r Ú string_typesri ÚparserR rh Ú TypeError©r r r r rS Û s
|
|
|
|
c C s t | ||¡S )zDReturn `name` entry point of `group` for `dist` or raise ImportError)rS rT ©r rK rä r r r rT æ s c C s t | |¡S )ú=Return the entry point map for `group`, or the full entry map)rS rU )r rK r r r rU ë s c C s t | ||¡S ©z<Return the EntryPoint object for `group`+`name`, or ``None``)rS rV ré r r r rV ð s c @ s< e Zd Zdd Zdd Zdd Zdd Zd d
|
Zd d Zd S )r c C s dS )z;Does the package's distribution contain the named metadata?Nr ©rä r r r Ú has_metadataö s z IMetadataProvider.has_metadatac C s dS )z'The named metadata resource as a stringNr rì r r r Ú get_metadataù s z IMetadataProvider.get_metadatac C s dS )zÒYield named metadata resource as list of non-blank non-comment lines
|
|
Leading and trailing whitespace is stripped from each line, and lines
|
with ``#`` as the first non-blank character are omitted.Nr rì r r r Úget_metadata_linesü s z$IMetadataProvider.get_metadata_linesc C s dS )z>Is the named metadata a directory? (like ``os.path.isdir()``)Nr rì r r r Úmetadata_isdir s z IMetadataProvider.metadata_isdirc C s dS )z?List of metadata names in the directory (like ``os.listdir()``)Nr rì r r r Úmetadata_listdir s z"IMetadataProvider.metadata_listdirc C s dS )z=Execute the named script in the supplied namespace dictionaryNr )râ Ú namespacer r r rQ s z IMetadataProvider.run_scriptN) r r r rí rî rï rð rñ rQ r r r r r õ s c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dS )r z3An object that provides access to package resourcesc C s dS )zdReturn a true filesystem path for `resource_name`
|
|
`manager` must be an ``IResourceManager``Nr ©ÚmanagerÚ resource_namer r r Úget_resource_filename s z'IResourceProvider.get_resource_filenamec C s dS )ziReturn a readable file-like object for `resource_name`
|
|
`manager` must be an ``IResourceManager``Nr ró r r r Úget_resource_stream s z%IResourceProvider.get_resource_streamc C s dS )zmReturn a string containing the contents of `resource_name`
|
|
`manager` must be an ``IResourceManager``Nr ró r r r Úget_resource_string s z%IResourceProvider.get_resource_stringc C s dS )z,Does the package contain the named resource?Nr ©rõ r r r Ú has_resource s z IResourceProvider.has_resourcec C s dS )z>Is the named resource a directory? (like ``os.path.isdir()``)Nr rù r r r r] ! s z IResourceProvider.resource_isdirc C s dS )z?List of resource names in the directory (like ``os.listdir()``)Nr rù r r r r[ $ s z"IResourceProvider.resource_listdirN)
|
r r r r rö r÷ rø rú r] r[ r r r r r s c @ s¬ e Zd ZdZd'ddZedd Zedd Zd d
|
Zd d Z d d Z
|
d(ddZ dd Z dd Z d)ddZd*ddZd+dd Zd d Zd,d d Zd!d" Zd#d$ Zd%d& ZdS )-rf zDA collection of active distributions on sys.path (or a similar list)Nc C s> g | _ i | _i | _g | _|dkr&tj}|D ]}| |¡ q*dS )z?Create working set from list of path entries (default=sys.path)N)ÚentriesÚ
|
entry_keysÚby_keyÚ callbacksrG r¿ Ú add_entry)r rû Úentryr r r Ú__init__+ s zWorkingSet.__init__c C sb | }zddl m} W n tk
|
r. | Y S X z| |¡ W n tk
|
r\ | |¡ Y S X |S )z1
|
Prepare the master working set.
|
r )Ú __requires__)Ú__main__r Ú ImportErrorrP rl Ú_build_from_requirements)ÚclsÚwsr r r r Ú _build_master8 s
|
zWorkingSet._build_masterc C sf | g }t |}| |t ¡}|D ]}| |¡ q"tjD ]}||jkr8| |¡ q8|jtjdd
< |S )zQ
|
Build a working set from a requirement spec. Rewrites sys.path.
|
N)rp Úresolvere ÚaddrG r¿ rû rÿ )r Úreq_specr ÚreqsÚdistsr r r r r r L s
|
|
z#WorkingSet._build_from_requirementsc C s< | j |g ¡ | j |¡ t|dD ]}| ||d¡ q$dS )aÝ Add a path item to ``.entries``, finding any distributions on it
|
|
``find_distributions(entry, True)`` is used to find distributions
|
corresponding to the path entry, and they are added. `entry` is
|
always appended to ``.entries``, even if it is already present.
|
(This is because ``sys.path`` can contain the same value more than
|
once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
|
equal ``sys.path``.)
|
TFN)rü Ú
|
setdefaultrû rà ra r
|
)r r r r r r rÿ b s
|
zWorkingSet.add_entryc C s | j |j¡|kS )z9True if `dist` is the active distribution for its project)rý rÊ r8 ©r r r r r Ú __contains__q s zWorkingSet.__contains__c C s, | j |j¡}|dk r(||kr(t|||S )aÐ Find a distribution matching requirement `req`
|
|
If there is an active distribution for the requested project, this
|
returns it as long as it meets the version requirement specified by
|
`req`. But, if there is an active distribution for the project and it
|
does *not* meet the `req` requirement, ``VersionConflict`` is raised.
|
If there is no active distribution for the requested project, ``None``
|
is returned.
|
N)rý rÊ r8 rl )r r r r r r r° u s
|
|
zWorkingSet.findc s fdd| D S )a Yield entry point objects from `group` matching `name`
|
|
If `name` is None, yields all entry points in `group` from all
|
distributions in the working set, otherwise only ones matching
|
both `group` and `name` are yielded (in distribution order).
|
c 3 s8 | ]0}| ¡ ¡ D ] }d ks*|jkr|V qqd S r )rU Úvaluesrä )Ú.0r r ©rK rä r r Ú <genexpr> s
|
ýz/WorkingSet.iter_entry_points.<locals>.<genexpr>r ©r rK rä r r r rW
s þz WorkingSet.iter_entry_pointsc C s> t d¡j}|d }| ¡ ||d< | |¡d ||¡ dS )z?Locate distribution for `requires` and run `script_name` scriptr r r Nrß )r Úrequiresrâ rã rä r r r rQ s
|
zWorkingSet.run_scriptc c sL i }| j D ]<}|| jkrq
|
| j| D ] }||kr$d||< | j| V q$q
|
dS )z¸Yield distributions for non-duplicate projects in the working set
|
|
The yield order is the order in which the items' path entries were
|
added to the working set.
|
r N)rû rü rý )r ÚseenÚitemr8 r r r Ú__iter__ s
|
|
zWorkingSet.__iter__TFc C s |r|j | j||d |dkr$|j}| j |g ¡}| j |jg ¡}|sV|j| jkrVdS || j|j< |j|krx| |j¡ |j|kr| |j¡ | |¡ dS )a Add `dist` to working set, associated with `entry`
|
|
If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
|
On exit from this routine, `entry` is added to the end of the working
|
set's ``.entries`` (if it wasn't already present).
|
|
`dist` is only added to the working set if it's for a project that
|
doesn't already have a distribution in the set, unless `replace=True`.
|
If it's added, any callbacks registered with the ``subscribe()`` method
|
will be called.
|
©rÓ N) Ú insert_onrû Úlocationrü r r8 rý rà Ú
|
_added_new)r r r ÚinsertrÓ ÚkeysÚkeys2r r r r
|
¬ s
|
|
zWorkingSet.addc C sx t |ddd
}i }i }g }t } t t¡}
|
|rt| d¡} | |krHq.| | |¡sVq.| | j¡} | dkr| j | j¡} | dks| | krø|rø| } |dkr¾| dkr®t
|
| j }nt
|
g }t g } |j | | ||d } || j< | dkrø|
|
| d¡}t| || | ¡ | | kr$|
|
| }t| | |¡| | j¡ddd
}| |¡ |D ] }|
|
| | j¡ | j| |< qHd|| < q.|S )aÎ List all distributions needed to (recursively) meet `requirements`
|
|
`requirements` must be a sequence of ``Requirement`` objects. `env`,
|
if supplied, should be an ``Environment`` instance. If
|
not supplied, it defaults to all distributions available within any
|
entry or distribution in the working set. `installer`, if supplied,
|
will be invoked with each requirement that cannot be met by an
|
already-installed distribution; it should return a ``Distribution`` or
|
``None``.
|
|
Unless `replace_conflicting=True`, raises a VersionConflict exception
|
if
|
any requirements are found on the path that have the correct name but
|
the wrong version. Otherwise, if an `installer` is supplied it will be
|
invoked to obtain the correct version of the requirement and activate
|
it.
|
|
`extras` is a list of the extras to be used with these requirements.
|
This is important because extra requirements may look like `my_req;
|
extra = "my_extra"`, which would otherwise be interpreted as a purely
|
optional requirement. Instead, we want to be able to assert that these
|
requirements are truly required.
|
Nrª r )Úreplace_conflictingT)ÚlistÚ
|
_ReqExtrasÚ collectionsÚ defaultdictÚsetÚpopÚ markers_passrÊ r8 rý re rû rf Ú
|
best_matchrm rà rl r¥ r ÚextrasÚextendr
|
Ú project_name)r Ú requirementsÚenvÚ installerr! r* Ú processedÚbestÚ to_activateÚ
|
req_extrasr¤ r r r r§ Ú dependent_reqÚnew_requirementsÚnew_requirementr r r r Ê sT
|
|
|
þ
|
|
|
|
|
zWorkingSet.resolvec C s
|
t |}| ¡ i }i }|dkr4t| j}||7 }n|| }| g ¡} t t| j| |D ]}
|
||
|
D ]} | ¡ g} z| | ||¡} W nB t k
|
rÈ } z$||| < |r®W Y ¢qfn
|
W Y ¢ qZW 5 d}~X Y qfX t t| j| |
|
t | ¡¡ qZqfqZt |}| ¡ ||fS )as Find all activatable distributions in `plugin_env`
|
|
Example usage::
|
|
distributions, errors = working_set.find_plugins(
|
Environment(plugin_dirlist)
|
)
|
# add plugins+libs to sys.path
|
map(working_set.add, distributions)
|
# display errors
|
print('Could not load', errors)
|
|
The `plugin_env` should be an ``Environment`` instance that contains
|
only distributions that are in the project's "plugin directory" or
|
directories. The `full_env`, if supplied, should be an ``Environment``
|
contains all currently-available distributions. If `full_env` is not
|
supplied, one is created automatically from the ``WorkingSet`` this
|
method is called on, which will typically mean that every directory on
|
``sys.path`` will be scanned for distributions.
|
|
`installer` is a standard installer callback as used by the
|
``resolve()`` method. The `fallback` flag indicates whether we should
|
attempt to resolve older versions of a plugin if the newest version
|
cannot be resolved.
|
|
This method returns a 2-tuple: (`distributions`, `error_info`), where
|
`distributions` is a list of the distributions found in `plugin_env`
|
that were loadable, along with any other distributions that are needed
|
to resolve their dependencies. `error_info` is a dictionary mapping
|
unloadable plugin distributions to an exception instance describing the
|
error that occurred. Usually this will be a ``DistributionNotFound`` or
|
``VersionConflict`` instance.
|
N) r" Úsortre rû r r r
|
Úas_requirementr rk r" r$ r% )r Ú
|
plugin_envÚfull_envr/ ÚfallbackÚplugin_projectsÚ
|
error_infoÚ distributionsr. Ú
|
shadow_setr, r r Ú resolveesr r r r Ú find_plugins& s4 $
|
|
|
|
|
zWorkingSet.find_pluginsc G s& | t|¡}|D ]}| |¡ q|S )a¾ Ensure that distributions matching `requirements` are activated
|
|
`requirements` must be a string or a (possibly-nested) sequence
|
thereof, specifying the distributions and versions required. The
|
return value is a sequence of the distributions that needed to be
|
activated to fulfill the requirements; all relevant distributions are
|
included, even if they were already activated in this working set.
|
)r rp r
|
)r r- Úneededr r r r rP z s zWorkingSet.requirec C s8 || j krdS | j |¡ |s"dS | D ] }|| q&dS )zInvoke `callback` for all distributions
|
|
If `existing=True` (default),
|
call on all existing ones, as well.
|
N)rþ rà )r ÚcallbackÚexistingr r r r Ú subscribe s
|
zWorkingSet.subscribec C s | j D ] }|| qd S r )rþ )r r rC r r r r s
|
zWorkingSet._added_newc C s, | j d d
| j ¡ | j ¡ | jd d
fS r )rû rü r2 rý rþ r r r r r/ s
|
þzWorkingSet.__getstate__c C s@ |\}}}}|d d
| _ | ¡ | _| ¡ | _|d d
| _d S r )rû r2 rü rý rþ )r Úe_k_b_crû r rý rþ r r r r1 ¢ s
|
|
|
zWorkingSet.__setstate__)N)N)NTF)NNFN)NNT)T)r r r r r Ú classmethodr r rÿ r r° rW rQ r r
|
r rA rP rE r r/ r1 r r r r rf ( s4
|
|
|
|
|
ÿ
|
] ÿ
|
T
|
c @ s e Zd ZdZdddZdS )r# z>
|
Map each requirement to the extras that demanded it.
|
Nc s2 fdd| d¡|pd D } j p0t|S )z»
|
Evaluate markers for req against each extra that
|
demanded it.
|
|
Return False if the req has a marker and fails
|
evaluation. Otherwise, return True.
|
c 3 s | ]} j d |i¡V qdS )ÚextraN©ÚmarkerÚevaluate)r rH ©r r r r · s ÿz*_ReqExtras.markers_pass.<locals>.<genexpr>r r )rÊ rJ Úany)r r r* Ú extra_evalsr rL r r( ¯ s
|
þz_ReqExtras.markers_pass)N)r r r r r( r r r r r# ª s r# c @ sx e Zd ZdZde efddZdd Zdd Zdd d
|
Z d d Z
|
d d Z dddZ d ddZ dd Zdd Zdd ZdS ) re z5Searchable snapshot of distributions on a search pathNc C s i | _ || _|| _| |¡ dS )a! Snapshot distributions available on a search path
|
|
Any distributions found on `search_path` are added to the environment.
|
`search_path` should be a sequence of ``sys.path`` items. If not
|
supplied, ``sys.path`` is used.
|
|
`platform` is an optional string specifying the name of the platform
|
that platform-specific distributions must be compatible with. If
|
unspecified, it defaults to the current platform. `python` is an
|
optional string naming the desired version of Python (e.g. ``'3.6'``);
|
it defaults to the current version.
|
|
You may explicitly set `platform` (and/or `python`) to ``None`` if you
|
wish to map *all* distributions, not just those compatible with the
|
running platform or Python version.
|
N)Ú_distmaprH ÚpythonÚscan)r Ú search_pathrH rP r r r r Á s zEnvironment.__init__c C s2 | j dkp |jdkp |j| j k}|o0t|j| jS )zåIs distribution `dist` acceptable for this environment?
|
|
The distribution must match the platform and python version
|
requirements specified when this environment was created, or False
|
is returned.
|
N)rP Ú
|
py_versionrt rH )r r Ú py_compatr r r Úcan_addÙ s
|
ÿ
|
ýzEnvironment.can_addc C s | j |j |¡ dS )z"Remove `dist` from the environmentN)rO r8 Úremover r r r rV ç s zEnvironment.removec C s4 |dkrt j}|D ] }t|D ]}| |¡ q qdS )ad Scan `search_path` for distributions usable in this environment
|
|
Any distributions found are added to the environment.
|
`search_path` should be a sequence of ``sys.path`` items. If not
|
supplied, ``sys.path`` is used. Only distributions conforming to
|
the platform/python version defined at initialization are added.
|
N)rG r¿ ra r
|
)r rR r r r r r rQ ë s
|
zEnvironment.scanc C s | ¡ }| j |g ¡S )a Return a newest-to-oldest list of distributions for `project_name`
|
|
Uses case-insensitive `project_name` comparison, assuming all the
|
project's distributions use their project's name converted to all
|
lowercase as their key.
|
|
)ÚlowerrO rÊ )r r, Údistribution_keyr r r Ú __getitem__ú s zEnvironment.__getitem__c C sL | |¡rH| ¡ rH| j |jg ¡}||krH| |¡ |jt d¡dd dS )zLAdd `dist` if we ``can_add()`` it and it has not already been added
|
ÚhashcmpT©r8 ÚreverseN) rU Ú has_versionrO r r8 rà r7 ÚoperatorÚ
|
attrgetter)r r r r r r r
|
s
|
|
zEnvironment.addFc C sf z| |¡}W n tk
|
r, |s$ d}Y nX |dk r:|S | |j D ]}||krD| S qD| ||¡S )a¸ Find distribution best matching `req` and usable on `working_set`
|
|
This calls the ``find(req)`` method of the `working_set` to see if a
|
suitable distribution is already active. (This may raise
|
``VersionConflict`` if an unsuitable version of the project is already
|
active in the specified `working_set`.) If a suitable distribution
|
isn't active, this method returns the newest distribution in the
|
environment that meets the ``Requirement`` in `req`. If no suitable
|
distribution is found, and `installer` is supplied, then the result of
|
calling the environment's ``obtain(req, installer)`` method will be
|
returned.
|
N)r° rl r8 Úobtain)r r r_ r/ r! r r r r r) s
|
|
zEnvironment.best_matchc C s |dk r||S dS )aÞ Obtain a distribution matching `requirement` (e.g. via download)
|
|
Obtain a distro that matches requirement (e.g. via download). In the
|
base ``Environment`` class, this routine just returns
|
``installer(requirement)``, unless `installer` is None, in which case
|
None is returned instead. This method is a hook that allows subclasses
|
to attempt other ways of obtaining a distribution before falling back
|
to the `installer` argument.Nr )r Ú requirementr/ r r r r` * s zEnvironment.obtainc c s" | j ¡ D ]}| | r
|
|V q
|
dS )z=Yield the unique project names of the available distributionsN)rO r ©r r8 r r r r 6 s zEnvironment.__iter__c C sV t |tr| |¡ n<t |trD|D ] }|| D ]}| |¡ q0q$ntd|f | S )z2In-place addition of a distribution or environmentzCan't add %r to environment)r¯ rh r
|
re rç )r ÚotherÚprojectr r r r Ú__iadd__< s
|
|
zEnvironment.__iadd__c C s* | j g ddd}| |fD ] }||7 }q|S )z4Add an environment or distribution to an environmentN)rH rP ©r )r rc Únewr. r r r Ú__add__H s
|
zEnvironment.__add__)N)NF)N)r r r r rO ÚPY_MAJORr rU rV rQ rY r
|
r) r` r re rh r r r r re ¾ s" þ
|
|
|
ÿ
|
|
c @ s e Zd ZdZdS )ro aT An error occurred extracting a resource
|
|
The following attributes are available from instances of this exception:
|
|
manager
|
The resource manager that raised this exception
|
|
cache_path
|
The base directory for resource extraction
|
|
original_error
|
The exception instance that caused extraction to fail
|
Nr r r r r ro T s c @ s e Zd ZdZdZdd Zdd Zdd Zd d
|
Zd d Z d d Z
|
dd Z dd Z d ddZ edd Zdd Zdd Zd d d ZdS )!rg z'Manage resource extraction and packagesNc C s
|
i | _ d S r )Ú cached_filesr r r r r h s zResourceManager.__init__c C s t | |¡S )z Does the named resource exist?)rR rú ©r Úpackage_or_requirementrõ r r r r\ k s z ResourceManager.resource_existsc C s t | |¡S )z,Is the named resource an existing directory?)rR r] rk r r r r] o s ÿz ResourceManager.resource_isdirc C s t | | |¡S )z4Return a true filesystem path for specified resource)rR rö rk r r r rZ u s ÿz!ResourceManager.resource_filenamec C s t | | |¡S )z9Return a readable file-like object for specified resource)rR r÷ rk r r r rY { s ÿz ResourceManager.resource_streamc C s t | | |¡S )z%Return specified resource as a string)rR rø rk r r r rX s ÿz ResourceManager.resource_stringc C s t | |¡S )z1List the contents of the named resource directory)rR r[ rk r r r r[ s ÿz ResourceManager.resource_listdirc C sR t ¡ d }| jpt }t d¡ ¡ }t|jf t }| |_
|
||_ ||_ |dS )z5Give an error message for problems extracting file(s)r a
|
Can't extract file(s) to egg cache
|
|
The following error occurred while trying to extract file(s)
|
to the Python egg cache:
|
|
{old_exc}
|
|
The Python egg cache directory is currently set to:
|
|
{cache_path}
|
|
Perhaps your account does not have write access to this directory?
|
You can change the cache directory by setting the PYTHON_EGG_CACHE
|
environment variable to point to an accessible directory.
|
N) rG Úexc_infoÚextraction_pathrd ÚtextwrapÚdedentÚlstripro r r¡ rô Ú
|
cache_pathÚoriginal_error)r Úold_excrr ÚtmplÚerrr r r Úextraction_error s z ResourceManager.extraction_errorr c C sf | j p
|
t }tjj||d f| }z t| W n tk
|
rL | ¡ Y nX | |¡ d| j |< |S )a® Return absolute location in cache for `archive_name` and `names`
|
|
The parent directory of the resulting path will be created if it does
|
not already exist. `archive_name` should be the base filename of the
|
enclosing egg (which may not be the name of the enclosing zipfile!),
|
including its ".egg" extension. `names`, if provided, should be a
|
sequence of path name parts "under" the egg's extraction location.
|
|
This method should only be called by resource providers that need to
|
obtain an extraction location, and only for names they intend to
|
extract, as it tracks the generated names for possible cleanup later.
|
z-tmpr )
|
rn rd r¾ r¿ rI Ú_bypass_ensure_directoryÚ Exceptionrw Ú _warn_unsafe_extraction_pathrj )r Ú archive_nameÚnamesÚ extract_pathÚ target_pathr r r Úget_cache_path© s
|
|
z ResourceManager.get_cache_pathc C s\ t jdkr | t jd ¡s dS t | ¡j}|tj@ s>|tj@ rXdjf t }t
|
|t ¡ dS )aN
|
If the default extraction path is overridden and set to an insecure
|
location, such as /tmp, it opens up an opportunity for an attacker to
|
replace an extracted file with an unauthorized payload. Warn the user
|
if a known insecure location is used.
|
|
See Distribute #375 for more details.
|
ÚntÚwindirNzáExtraction path is writable by group/others and vulnerable to attack when used with get_resource_filename ({path}). Consider a more secure location (set with .set_extraction_path or the PYTHON_EGG_CACHE environment variable).) r¾ rä rÑ ÚenvironÚstatÚst_modeÚS_IWOTHÚS_IWGRPr r¡ ÚwarningsÚwarnÚ UserWarning)r¿ ÚmodeÚmsgr r r rz  s
|
ÿùz,ResourceManager._warn_unsafe_extraction_pathc C s. t jdkr*t |¡jdB d@ }t ||¡ dS )a4 Perform any platform-specific postprocessing of `tempname`
|
|
This is where Mac header rewrites should be done; other platforms don't
|
have anything special they should do.
|
|
Resource providers should call this method ONLY after successfully
|
extracting a compressed resource. They must NOT call it on resources
|
that are already in the filesystem.
|
|
`tempname` is the current (temporary) name of the file, and `filename`
|
is the name it will be renamed to by the caller after this routine
|
returns.
|
Úposixim iÿ N)r¾ rä r r Úchmod)r ÚtempnameÚfilenamer r r r Ú postprocessÝ s
|
zResourceManager.postprocessc C s | j rtd|| _dS )aÒ Set the base path where resources will be extracted to, if needed.
|
|
If you do not call this routine before any extractions take place, the
|
path defaults to the return value of ``get_default_cache()``. (Which
|
is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
|
platform-specific fallbacks. See that routine's documentation for more
|
details.)
|
|
Resources are extracted to subdirectories of this path based upon
|
information given by the ``IResourceProvider``. You may set this to a
|
temporary directory, but then you must call ``cleanup_resources()`` to
|
delete the extracted files when done. There is no guarantee that
|
``cleanup_resources()`` will be able to remove all extracted files.
|
|
(Note: you may not change the extraction path for a given resource
|
manager once resources have been extracted, unless you first call
|
``cleanup_resources()``.)
|
z5Can't change extraction path, files already extractedN)rj rL rn ©r r¿ r r r rb ñ s
|
ÿz#ResourceManager.set_extraction_pathFc C s dS )aB
|
Delete all extracted resource files and directories, returning a list
|
of the file and directory names that could not be successfully removed.
|
This function does not have any concurrency protection, so it should
|
generally only be called when the extraction path is a temporary
|
directory exclusive to a single process. This method is not
|
automatically called; you must call it explicitly or register it as an
|
``atexit`` function if you wish to ensure cleanup of a temporary
|
directory used for extractions.
|
Nr )r Úforcer r r rc s z!ResourceManager.cleanup_resources)r )F)r r r r rn r r\ r] rZ rY rX r[ rw r Ú staticmethodrz r rb rc r r r r rg d s
|
|
c C s t j d¡ptjddS )z
|
Return the ``PYTHON_EGG_CACHE`` environment variable
|
or a platform-relevant user cache dir for an app
|
named "Python-Eggs".
|
ÚPYTHON_EGG_CACHEz Python-Eggs)Úappname)r¾ r rÊ r Úuser_cache_dirr r r r rd s
|
þc C s t dd| ¡S )zConvert an arbitrary string to a standard distribution name
|
|
Any runs of non-alphanumeric/. characters are replaced with a single '-'.
|
ú[^A-Za-z0-9.]+ú-)ÚreÚsubrì r r r rq % s c C sJ zt tj | ¡W S tjjk
|
rD | dd¡} t dd| ¡ Y S X dS )zB
|
Convert an arbitrary string to a standard version string
|
rÎ rB r r N)r± r r r r rÓ r r )r r r r rr - s
|
c C s t dd| ¡ ¡ S )z±Convert an arbitrary string to a standard 'extra' name
|
|
Any runs of non-alphanumeric characters are replaced with a single '_',
|
and the result is always lowercased.
|
z[^A-Za-z0-9.-]+rÏ )r r rW )rH r r r rw 9 s c C s | dd¡S )z|Convert a project or version name to its filename-escaped form
|
|
Any '-' characters are currently replaced with '_'.
|
r rÏ r rì r r r rx B s c
|
C sH z t | W n6 tk
|
rB } zd|_d|_| W Y ¢S d}~X Y nX dS )zo
|
Validate text as a PEP 508 environment marker; return an exception
|
if invalid or False otherwise.
|
NF)rz Ú SyntaxErrorr Úlineno)ÚtextÚer r r ry J s c
|
C sL zt j | ¡}| ¡ W S t jjk
|
rF } zt||W 5 d}~X Y nX dS )zÙ
|
Evaluate a PEP 508 environment marker.
|
Return a boolean indicating the marker result in this environment.
|
Raise SyntaxError if marker is invalid.
|
|
This implementation uses the 'pyparsing' module.
|
N)r ÚmarkersÚMarkerrK Ú InvalidMarkerr )r rH rJ r r r r rz X s
|
|
c @ sÀ e Zd ZdZdZdZdZdd Zdd Zdd Z d d
|
Z
|
d d Z d d Z dd Z dd Zdd Zdd Zdd Zdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zed'd( Zd)d* ZdS )+r zETry to implement resources and metadata for arbitrary PEP 302 loadersNc C s( t |dd | _tj t |dd¡| _d S )Nr® Ú__file__rº )rµ r¹ r¾ r¿ ÚdirnameÚ module_path©r r¸ r r r r n s zNullProvider.__init__c C s | | j|¡S r )Ú_fnr¤ ©r rô rõ r r r rö r s z"NullProvider.get_resource_filenamec C s t | ||¡¡S r )ÚioÚBytesIOrø r§ r r r r÷ u s z NullProvider.get_resource_streamc C s | | | j|¡¡S r )Ú_getr¦ r¤ r§ r r r rø x s z NullProvider.get_resource_stringc C s | | | j|¡¡S r )Ú_hasr¦ r¤ ©r rõ r r r rú { s zNullProvider.has_resourcec C s | | j|¡S r )r¦ Úegg_info©r rä r r r Ú_get_metadata_path~ s z NullProvider._get_metadata_pathc C s | j s | j S | |¡}| |¡S r )r r¯ r« ©r rä r¿ r r r rí s
|
zNullProvider.has_metadatac
|
C st | j s
|
dS | |¡}| |¡}tjr(|S z | d¡W S tk
|
rn } z | jd ||¡7 _ W 5 d }~X Y nX d S )Nrº úutf-8z in {} file at path: {}) r r¯ rª r ÚPY2ÚdecodeÚUnicodeDecodeErrorÚreasonr )r rä r¿ ÚvalueÚexcr r r rî s
|
|
zNullProvider.get_metadatac C s t | |¡S r ©ru rî r® r r r rï s z NullProvider.get_metadata_linesc C s | | | j|¡¡S r )Ú_isdirr¦ r¤ r¬ r r r r] s zNullProvider.resource_isdirc C s | j o| | | j |¡¡S r )r r¹ r¦ r® r r r rð s zNullProvider.metadata_isdirc C s | | | j|¡¡S r )Ú_listdirr¦ r¤ r¬ r r r r[ s z NullProvider.resource_listdirc C s | j r| | | j |¡¡S g S r )r rº r¦ r® r r r rñ £ s z NullProvider.metadata_listdirc C sÜ d| }| |¡s$tdjf t | |¡ dd¡}| dd¡}| | j|¡}||d< tj
|
|¡rt |}| ¡ }W 5 Q R X t ||d}t||| n>dd lm} t|d| d¡|f| |< t ||d}
|
t|
|
|| d S )
|
Nzscripts/z<Script {script!r} not found in metadata at {self.egg_info!r}z
|
Ú
|
ú r¢ Úexecr )Úcache)rí rk r r¡ rî rÓ r¦ r r¾ r¿ rÀ r ÚreadÚcompiler½ Ú linecacher¾ Úlenr ) r râ rò ÚscriptÚ script_textÚscript_filenameZfidÚsourceÚcoder¾ Ú script_coder r r rQ ¨ s0
|
ÿÿ
|
ÿ zNullProvider.run_scriptc C s t dd S ©Nz9Can't perform this operation for unregistered loader type©ÚNotImplementedErrorr r r r r« À s ÿzNullProvider._hasc C s t dd S rÉ rÊ r r r r r¹ Å s ÿzNullProvider._isdirc C s t dd S rÉ rÊ r r r r rº Ê s ÿzNullProvider._listdirc C s* | |¡ |r&tjj|f| d¡ S |S )Nú/)Ú_validate_resource_pathr¾ r¿ rI r )r Úbaserõ r r r r¦ Ï s
|
zNullProvider._fnc C sp t jj| tj¡kp&t | ¡p&t | ¡}|s0dS d}t | ¡rPt | ¡sPt|t j
|
|dd
d t dd dS )aO
|
Validate the resource paths according to the docs.
|
https://setuptools.readthedocs.io/en/latest/pkg_resources.html#basic-resource-access
|
|
>>> warned = getfixture('recwarn')
|
>>> warnings.simplefilter('always')
|
>>> vrp = NullProvider._validate_resource_path
|
>>> vrp('foo/bar.txt')
|
>>> bool(warned)
|
False
|
>>> vrp('../foo/bar.txt')
|
>>> bool(warned)
|
True
|
>>> warned.clear()
|
>>> vrp('/foo/bar.txt')
|
>>> bool(warned)
|
True
|
>>> vrp('foo/../../bar.txt')
|
>>> bool(warned)
|
True
|
>>> warned.clear()
|
>>> vrp('foo/f../bar.txt')
|
>>> bool(warned)
|
False
|
|
Windows path separators are straight-up disallowed.
|
>>> vrp(r'\foo/bar.txt')
|
Traceback (most recent call last):
|
...
|
ValueError: Use of .. or absolute path in a resource path is not allowed.
|
|
>>> vrp(r'C:\foo/bar.txt')
|
Traceback (most recent call last):
|
...
|
ValueError: Use of .. or absolute path in a resource path is not allowed.
|
|
Blank values are allowed
|
|
>>> vrp('')
|
>>> bool(warned)
|
False
|
|
Non-string values are not.
|
|
>>> vrp(None)
|
Traceback (most recent call last):
|
...
|
AttributeError: ...
|
Nz=Use of .. or absolute path in a resource path is not allowed.rª z/ and will raise exceptions in a future release.rÍ ©Ú
|
stacklevel) r¾ r¿ Úpardirr Ú posixpathÚsepÚisabsÚntpathrL r r ÚDeprecationWarning)r¿ Úinvalidr r r r rÍ Õ s 6ÿýýz$NullProvider._validate_resource_pathc C s$ t | jdr| j |¡S tdd S )NÚget_dataz=Can't perform this operation for loaders without 'get_data()')rÁ r¹ rØ rË r r r r rª s
|
ÿzNullProvider._get) r r r r Úegg_namer r¹ r rö r÷ rø rú r¯ rí rî rï r] rð r[ rñ rQ r« r¹ rº r¦ r rÍ rª r r r r r g s2
|
Jc c s, d}| |kr(| V | }t j | ¡\} }qdS )z2
|
yield all parents of path including path
|
N)r¾ r¿ r )r¿ ÚlastrÏ r r r Ú_parents+ s
|
rÛ c @ s( e Zd ZdZdd Zdd Zdd ZdS ) r z&Provider based on a virtual filesystemc C s t | |¡ | ¡ d S r )r r Ú _setup_prefixr¥ r r r r 9 s zEggProvider.__init__c C s, t tt| j}t|d }|o&| |¡ d S r )r Ú _is_egg_pathrÛ r¤ ÚnextÚ_set_egg)r ÚeggsZeggr r r rÜ = s
|
zEggProvider._setup_prefixc C s( t j |¡| _t j |d¡| _|| _d S )NúEGG-INFO)r¾ r¿ ÚbasenamerÙ rI r Úegg_rootr r r r rß D s zEggProvider._set_eggN)r r r r r rÜ rß r r r r r 6 s c @ sD e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Ze d d Z
|
dS )r z6Provides access to package resources in the filesystemc C s t j |¡S r )r¾ r¿ rÀ r r r r r« M s zDefaultProvider._hasc C s t j |¡S r )r¾ r¿ r r r r r r¹ P s zDefaultProvider._isdirc C s
|
t |¡S r )r¾ Úlistdirr r r r rº S s zDefaultProvider._listdirc C s t | | j|¡dS ©NÚrb)r r¦ r¤ r§ r r r r÷ V s z#DefaultProvider.get_resource_streamc
|
C s* t |d}| ¡ W 5 Q R £ S Q R X d S rå )r r¿ )r r¿ Ústreamr r r rª Y s zDefaultProvider._getc C s, d}|D ] }t t|td }t|| qd S )N)ÚSourceFileLoaderÚSourcelessFileLoader)rµ Úimportlib_machineryÚtyper )r Ú loader_namesrä Ú
|
loader_clsr r r Ú _register] s zDefaultProvider._registerN) r r r r r« r¹ rº r÷ rª rG rî r r r r r J s c @ s8 e Zd ZdZdZdd ZZdd Zdd Zd d
|
Z dS ) r z.Provider that returns nothing for all requestsNc C s dS ©NFr r r r r r? m r@ zEmptyProvider.<lambda>c C s dS ©Nrº r r r r r rª o s zEmptyProvider._getc C s g S r r r r r r rº r s zEmptyProvider._listdirc C s d S r r r r r r r u s zEmptyProvider.__init__)
|
r r r r r¤ r¹ r« rª rº r r r r r r h s c @ s e Zd ZdZedd ZeZdS )Ú ZipManifestsz
|
zip manifest builder
|
c
|
s@ t |¡, fdd ¡ D }t|W 5 Q R £ S Q R X dS )a
|
Build a dictionary similar to the zipimport directory
|
caches, except instead of tuples, store ZipInfo objects.
|
|
Use a platform-specific path separator (os.sep) for the path keys
|
for compatibility with pypy on Windows.
|
c 3 s& | ] }| d tj¡ |¡fV qdS )rÌ N)rÓ r¾ rÓ Úgetinfo©r rä ©Úzfiler r r s ý þz%ZipManifests.build.<locals>.<genexpr>N)ÚzipfileÚZipFileÚnamelistr$ )r r¿ r* r rô r Úbuild s
|
|
ûzZipManifests.buildN)r r r r rG rù Úloadr r r r rñ | s
|
rñ c @ s$ e Zd ZdZe dd¡Zdd ZdS )ÚMemoizedZipManifestsz%
|
Memoized zipfile manifests.
|
Ú manifest_modzmanifest mtimec C sR t j |¡}t |¡j}|| ks.| | j|krH| |¡}| ||¡| |< | | jS )zW
|
Load a manifest at path or return a suitable manifest already loaded.
|
) r¾ r¿ Únormpathr Úst_mtimeÚmtimerù rü Úmanifest)r r¿ rÿ r r r r rú s
|
zMemoizedZipManifests.loadN)r r r r r$ Ú
|
namedtuplerü rú r r r r rû s rû c @ s e Zd ZdZdZe Zdd Zdd Zdd Z e
|
d d
|
Z d d Z e d d Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd d Zd d ZdS )!r z"Resource support for zips and eggsNc C s t | |¡ | jjtj | _d S r )r r r¹ Úarchiver¾ rÓ Úzip_prer¥ r r r r ± s zZipProvider.__init__c C sP | tj¡}|| jjkr dS | | j¡r:|t| jd
S td|| jf d S )Nrº ú%s is not a subpath of %s) Úrstripr¾ rÓ r¹ r rÑ r r ÚAssertionError©r Úfspathr r r Ú _zipinfo_nameµ s ÿzZipProvider._zipinfo_namec C sP | j | }| | jtj ¡r:|t| jd d
tj¡S td|| jf d S )Nr r )r rÑ rã r¾ rÓ r r r )r Úzip_pathr r r r Ú_partsÁ s
|
ÿzZipProvider._partsc C s | j | jj¡S r )Ú_zip_manifestsrú r¹ r r r r r ÚzipinfoË s zZipProvider.zipinfoc C s\ | j std| |¡}| ¡ }d | |¡¡|krP|D ]}| || |¡¡ q8| ||¡S )Nz5resource_filename() only supported for .egg, not .ziprÌ )rÙ rË Ú_resource_to_zipÚ_get_eager_resourcesrI r Ú_extract_resourceÚ _eager_to_zip)r rô rõ r
|
Úeagersrä r r r rö Ï s ÿ
|
z!ZipProvider.get_resource_filenamec C s" | j }| jd }t |¡}||fS )N)r r rª )Ú file_sizeÚ date_timeÚtimeÚmktime)Úzip_statÚsizer Ú timestampr r r Ú_get_date_and_sizeÜ s
|
|
z ZipProvider._get_date_and_sizec
|
C sx || ¡ kr@| ¡ | D ]}| |tj ||¡¡}qtj |¡S | | j| ¡\}}ts`t dzò|
|
| j | |¡¡}| ||¡r|W S tdtj |¡d\}} t || j |¡¡ t |¡ t| ||f | | |¡ zt| | W nh tjk
|
rN tj |¡rH| ||¡r | Y W S tjdkrHt| t| | | Y W S Y nX W n tjk
|
rr | ¡ Y nX |S )Nz>"os.rename" and "os.unlink" are not supported on this platformz .$extract)Údirr )Ú_indexr r¾ r¿ rI r£ r r Ú WRITE_SUPPORTÚIOErrorr rÙ r Ú _is_currentÚ_mkstempÚwriter¹ rØ Úcloser r r ÚerrorÚisfilerä r
|
rw )
|
r rô r
|
rä rÚ r r Ú real_pathÚoutfÚtmpnamr r r r å sN ÿ ÿ
|
þ
|
|
|
|
|
z ZipProvider._extract_resourcec C sx | | j| ¡\}}tj |¡s$dS t |¡}|j|ksB|j|krFdS | j |¡}t
|
|d}| ¡ }W 5 Q R X ||kS )zK
|
Return True if the file_path is current for this zip_path
|
Fræ ) r r r¾ r¿ r$ r Úst_sizerþ r¹ rØ r r¿ ) r Ú file_pathr
|
r r r Ú zip_contentsÚfÚ file_contentsr r r r s
|
zZipProvider._is_currentc C s> | j d kr8g }dD ] }| |¡r| | |¡¡ q|| _ | j S )N)znative_libs.txtzeager_resources.txt)r rí r+ rï )r r rä r r r r , s
|
|
z ZipProvider._get_eager_resourcesc C s z| j W S tk
|
r i }| jD ]V}| tj¡}|r"tj |d d
¡}||krh|| |d ¡ q"q2| ¡ g||< q2q"|| _ | Y S X d S )Nrª ) Ú _dirindexÚAttributeErrorr r r¾ rÓ rI rà r' )r Úindr¿ ÚpartsÚparentr r r r 5 s
|
zZipProvider._indexc C s | |¡}|| jkp || ¡ kS r )r r r )r r r
|
r r r r« F s
|
zZipProvider._hasc C s | |¡| ¡ kS r )r r r r r r r¹ J s zZipProvider._isdirc C s t | ¡ | |¡d¡S ©Nr )r" r rÊ r r r r r rº M s zZipProvider._listdirc C s | | | j|¡¡S r )r r¦ rã r¬ r r r r P s zZipProvider._eager_to_zipc C s | | | j|¡¡S r )r r¦ r¤ r¬ r r r r S s z ZipProvider._resource_to_zip)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 « s(
|
|
|
7 c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dS )r a* Metadata handler for standalone PKG-INFO files
|
|
Usage::
|
|
metadata = FileMetadata("/path/to/PKG-INFO")
|
|
This provider rejects all data and metadata requests except for PKG-INFO,
|
which is treated as existing, and will be the contents of the file at
|
the provided location.
|
c C s
|
|| _ d S r ©r¿ r r r r r f s zFileMetadata.__init__c C s | j S r r3 r® r r r r¯ i s z FileMetadata._get_metadata_pathc C s |dkot j | j¡S )NúPKG-INFO)r¾ r¿ r$ r® r r r rí l s zFileMetadata.has_metadatac C sD |dkrt dtj| jddd}| ¡ }W 5 Q R X | |¡ |S )Nr4 z(No metadata except PKG-INFO is availabler± rÓ )ÚencodingÚerrors)r³ r¨ r r¿ r¿ Ú_warn_on_replacement)r rä r+ Úmetadatar r r rî o s
|
zFileMetadata.get_metadatac C s2 d d¡}||kr.d}|jf t }t |¡ d S )Ns �r± z2{self.path} could not be properly decoded in UTF-8)r³ r r¡ r r )r r8 Úreplacement_charru r r r r r7 x s
|
|
z!FileMetadata._warn_on_replacementc C s t | |¡S r r¸ r® r r r rï s z FileMetadata.get_metadata_linesN)
|
r r r r r r¯ rí rî r7 rï r r r r r Z s c @ s e Zd ZdZdd ZdS )r
as Metadata provider for egg directories
|
|
Usage::
|
|
# Development eggs:
|
|
egg_info = "/path/to/PackageName.egg-info"
|
base_dir = os.path.dirname(egg_info)
|
metadata = PathMetadata(base_dir, egg_info)
|
dist_name = os.path.splitext(os.path.basename(egg_info))[0]
|
dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
|
|
# Unpacked egg directories:
|
|
egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
|
metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
|
dist = Distribution.from_filename(egg_path, metadata=metadata)
|
c C s || _ || _d S r )r¤ r )r r¿ r r r r r s zPathMetadata.__init__N©r r r r r r r r r r
s c @ s e Zd ZdZdd ZdS )r z Metadata provider for .egg filesc C sD |j tj | _|| _|jr0tj |j |j¡| _n|j | _| ¡ dS )z-Create a metadata provider from a zipimporterN)
|
r r¾ rÓ r r¹ Úprefixr¿ rI r¤ rÜ )r Úimporterr r r r s zEggMetadata.__init__Nr: r r r r r s r$ ©Ú_distribution_findersc C s |t | < dS )ax Register `distribution_finder` to find distributions in sys.path items
|
|
`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
|
handler), and `distribution_finder` is a callable that, passed a path
|
item and the importer instance, yields ``Distribution`` instances found on
|
that path item. See ``pkg_resources.find_on_path`` for an example.Nr= )Ú importer_typeÚdistribution_finderr r r r ¯ s c C s t | }tt|}||| |S )z.Yield distributions accessible via `path_item`)r r¶ r> )Ú path_itemÚonlyr< Úfinderr r r ra ¹ s
|
c c sÆ | j d¡rdS t| }| d¡r2tj||dV |r:dS | d¡D ]|}t|rtj
|
||¡}t t |¡|}|D ]
|
}|V qrqD| ¡ d¡rDtj
|
||¡}tt |¡}||_t |||¡V qDdS )z@
|
Find eggs in zip files; possibly multiple nested eggs.
|
z.whlNr4 ©r8 rº ú
|
.dist-info)r Úendswithr rí rh Ú from_filenamer[ rÝ r¾ r¿ rI Úfind_eggs_in_zipÚ zipimportÚ zipimporterrW r Ú from_location) r< rA rB r8 ÚsubitemÚsubpathr r Úsubmetar r r rH À s$
|
|
rH c C s dS r2 r )r< rA rB r r r Ú find_nothingÞ s rO c C s dd }t | |ddS )aL
|
Given a list of filenames, return them in descending order
|
by version number.
|
|
>>> names = 'bar', 'foo', 'Python-2.7.10.egg', 'Python-2.7.2.egg'
|
>>> _by_version_descending(names)
|
['Python-2.7.10.egg', 'Python-2.7.2.egg', 'foo', 'bar']
|
>>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.egg'
|
>>> _by_version_descending(names)
|
['Setuptools-1.2.3.egg', 'Setuptools-1.2.3b1.egg']
|
>>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.post1.egg'
|
>>> _by_version_descending(names)
|
['Setuptools-1.2.3.post1.egg', 'Setuptools-1.2.3b1.egg']
|
c S s2 t j | ¡\} }t | d¡|g¡}dd |D S )z6
|
Parse each component of the filename
|
r c S s g | ]}t j |¡qS r )r r ræ )r Úpartr r r Ú
|
<listcomp>ú s z?_by_version_descending.<locals>._by_version.<locals>.<listcomp>)r¾ r¿ ÚsplitextÚ itertoolsÚchainr )rä Úextr0 r r r Ú _by_versionô s z+_by_version_descending.<locals>._by_versionTr[ )Úsorted)r| rV r r r Ú_by_version_descendingå s rX c
|
# s t tr4tjttj d¡dV dS t} fdd|D }t |}|D ]2}tj |¡}t
|
| }||D ]
|
} | V qq\dS )z6Yield distributions accessible on a sys.path directoryrá rD Nc 3 s | ]}t | r|V qd S r )Ú dist_factory)r r ©rB rA r r r s þz find_on_path.<locals>.<genexpr>) Ú_normalize_cachedÚ_is_unpacked_eggrh rG r
r¾ r¿ rI Ú safe_listdirrX rY )
|
r< rA rB rû ÚfilteredÚpath_item_entriesr ÚfullpathÚfactoryr r rZ r Ú find_on_pathÿ s( ÿÿ þ rb c C sj | ¡ }| d¡}| d¡o0tj tj | |¡¡}|p8|}|rBtS |sRt|rRtS |sd| d¡rdt S t
|
S )z*Return a dist_factory for the given entry.ú .egg-inforE z .egg-link) rW rF r¾ r¿ r rI Údistributions_from_metadatarÝ ra Úresolve_egg_linkÚNoDists)rA r rB rW Z is_egg_infoZ is_dist_infoÚis_metar r r rY s$
|
|
þÿÿÿÿÿùrY c @ s* e Zd ZdZdd Zejr eZdd ZdS )rf zS
|
>>> bool(NoDists())
|
False
|
|
>>> list(NoDists()('anything'))
|
[]
|
c C s dS rï r r r r r Ú__bool__; s zNoDists.__bool__c C s t dS r2 )Úiter)r r` r r r Ú__call__@ s zNoDists.__call__N) r r r r rh r r² Ú __nonzero__rj r r r r rf 3 s
|
rf c
|
C sv z t | ¡W S ttfk
|
r$ Y nN tk
|
rp } z0|jtjtjtjfkpXt |dddk}|s` W 5 d}~X Y nX dS )zI
|
Attempt to list contents of path, but suppress some exceptions.
|
ÚwinerrorNi r )
|
r¾ rä ÚPermissionErrorÚNotADirectoryErrorÚOSErrorÚerrnoÚENOTDIRÚEACCESÚENOENTrµ )r¿ r Ú ignorabler r r r] D s ýr] c c sf t j | ¡}t j | ¡r:tt | ¡dkr.d S t|| }nt| }t j | ¡}t j
|
|||t dV d S )Nr )Ú
|
precedence) r¾ r¿ r£ r r rä r
r râ rh rK r )r¿ Úrootr8 r r r r rd Y s ÿrd c c s4 t | "}|D ]}| ¡ }|r|V qW 5 Q R X dS )z1
|
Yield non-empty lines from file at path
|
N)r Ústrip)r¿ r+ Úliner r r Únon_empty_linesh s
|
|
ry c s. t } fdd|D }tt|}t|dS )za
|
Given a path to an .egg-link, resolve distributions
|
present in the referenced path.
|
c 3 s$ | ] }t j t j ¡|¡V qd S r )r¾ r¿ rI r£ )r Úrefr3 r r r y s ÿz#resolve_egg_link.<locals>.<genexpr>r )ry r ra rÞ )r¿ Úreferenced_pathsÚresolved_pathsÚ dist_groupsr r3 r re s s
|
þ
|
re Ú
|
FileFinder©Ú_namespace_handlers)Ú_namespace_packagesc C s |t | < dS )a Register `namespace_handler` to declare namespace packages
|
|
`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
|
handler), and `namespace_handler` is a callable like this::
|
|
def namespace_handler(importer, path_entry, moduleName, module):
|
# return a path_entry to use for child packages
|
|
Namespace handlers are only called if the importer object has already
|
agreed that it can handle the relevant path item, and they should only
|
return a subpath if the module __path__ does not already contain an
|
equivalent subpath. For an example namespace handler, see
|
``pkg_resources.file_ns_handler``.
|
Nr )r? Únamespace_handlerr r r r s c C s t |}|dkrdS z| | ¡j}W n< tk
|
r` t ¡ t d¡ | | ¡}W 5 Q R X Y nX |dkrndS tj
|
| ¡}|dkr¦t | ¡ }tj | < g |_ t| nt|dsºtd| tt|}|||| |}|dk r|j }| |¡ | | ¡ t|| | |S )zEEnsure that named package includes a subpath of path_item (if needed)NÚignoreÚ__path__úNot a package:)r Ú find_specr¹ r. r Úcatch_warningsÚ simplefilterÚ find_modulerG r² rÊ ÚtypesÚ
|
ModuleTyper Ú_set_parent_nsrÁ rç r¶ r rÃ Ú load_moduleÚ_rebuild_mod_path)Ú packageNamerA r< r¹ r¸ ÚhandlerrM r¿ r r r Ú
|
_handle_ns s4
|
|
|
|
|
|
|
|
|
r c sj dd t jD fdd fdd}t| |d}dd |D }t|jtr`||jd d
< n||_d S )
|
zq
|
Rebuild module.__path__ ensuring that all entries are ordered
|
corresponding to their sys.path order
|
c S s g | ] }t |qS r ©r[ ©r Úpr r r rQ Ä s z%_rebuild_mod_path.<locals>.<listcomp>c s. z | ¡W S tk
|
r( td Y S X dS )z/
|
Workaround for #520 and #513.
|
ÚinfN)ÚindexrL Úfloat)r )Úsys_pathr r Úsafe_sys_path_indexÆ s z._rebuild_mod_path.<locals>.safe_sys_path_indexc s< | tj¡} d¡d }|d|
}ttj |¡S )zR
|
Return the ordinal of the path based on its position in sys.path
|
rB r N)r r¾ rÓ Úcountr[ rI )r¿ Ú
|
path_partsÚ module_partsr0 )Ú package_namer r r Úposition_in_sys_pathÏ s z/_rebuild_mod_path.<locals>.position_in_sys_path)r8 c S s g | ] }t |qS r r r r r r rQ Ù s N)rG r¿ rW r¯ r r" )Ú orig_pathr r¸ r Únew_pathr )r r r r r ¿ s r c
|
C sÔ t ¡ z¼| tkrW ¢°dS tj}| d¡\}}}|rt| |tkrLt| ztj | j
|
}W n. t k
|
r } zt d||W 5 d}~X Y nX t |pdg ¡ | ¡ t | g ¡ |D ]}t| | q²W 5 t ¡ X dS )z9Declare that package 'packageName' is a namespace packageNrB r
)Ú_impÚ acquire_lockÚ release_lockr rG r¿ Ú
|
rpartitionr^ r´ r² r r. rç r rà r )r r¿ r1 rÏ r rA r r r r^ á s& c C sF t ¡ z.t |d¡D ] }t|| }|rt|| qW 5 t ¡ X dS )zDEnsure that previously-declared namespace packages include path_itemr N)r¡ r¢ r£ r rÊ r r )rA r1 ÚpackagerM r r r r s
|
c C sD t j || d¡d ¡}t|}|jD ]}t||kr& q@q&|S dS )zBCompute an ns-package subpath for a filesystem or zipfile importerrB rª N)r¾ r¿ rI r r[ r )r< rA r r¸ rM Ú
|
normalizedr r r r Úfile_ns_handler s
|
r§ c C s d S r r )r< rA r r¸ r r r Únull_ns_handler# s r¨ c C s t j t j t j t| ¡¡¡S )z1Normalize a file/dir name for comparison purposes)r¾ r¿ ÚnormcaseÚrealpathrý Ú _cygwin_patch©r r r r r| * s ÿc C s t jdkrtj | ¡S | S )a
|
Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
|
symlink components. Using
|
os.path.abspath() works around this limitation. A fix in os.getcwd()
|
would probably better, in Cygwin even more so, except
|
that this seems to be by design...
|
Úcygwin)rG rH r¾ r¿ Úabspathr¬ r r r r« 0 s r« c C s8 z
|
|| W S t k
|
r2 t| || < }| Y S X d S r )r³ r| )r rÄ Úresultr r r r[ ; s
|
|
r[ c C s | ¡ d¡S )z7
|
Determine if given path appears to be an egg.
|
ú.egg)rW rF r3 r r r rÝ C s rÝ c C s t | o tj tj | dd¡¡S )z@
|
Determine if given path appears to be an unpacked egg.
|
rá r4 )rÝ r¾ r¿ r$ rI r3 r r r r\ J s þr\ c C s< | d¡}| ¡ }|r8d |¡}ttj| |tj| d S )NrB )r r' rI ÚsetattrrG r² )r r0 rä r1 r r r r T s
|
|
|
r c c sZ t | tjr8| ¡ D ] }| ¡ }|r| d¡s|V qn | D ]}t|D ]
|
}|V qHq<dS )z9Yield non-empty/non-comment lines of a string or sequenceú#N)r¯ r rå Ú
|
splitlinesrw rÑ ru )ÚstrsÚsÚssr r r ru \ s
|
z \w+(\.\w+)*$z
|
(?P<name>[^-]+) (
|
-(?P<ver>[^-]+) (
|
-py(?P<pyver>[^-]+) (
|
-(?P<plat>.+)
|
)?
|
)?
|
)?
|
c @ s e Zd ZdZdddZdd Zdd Zdd d Zd d Zd ddZ e
|
d¡Z e d ddZe dd Ze d ddZe d ddZdS ) rj z3Object representing an advertised importable objectr Nc C s< t |std||| _|| _t|| _t|| _|| _d S )NzInvalid module name)ÚMODULErL rä Ú module_nameÚtupleÚattrsr* r )r rä r¸ rº r* r r r r r | s
|
|
|
zEntryPoint.__init__c C sH d| j | jf }| jr*|dd | j¡ 7 }| jrD|dd | j¡ 7 }|S )Nz%s = %sú:rB z [%s]ú,)rä r¸ rº rI r* )r rµ r r r r©
s zEntryPoint.__str__c C s dt | S )NzEntryPoint.parse(%r)©r± r r r r r s zEntryPoint.__repr__Tc O s4 |r |s |r t jdtdd |r,| j|| | ¡ S )zH
|
Require packages for this EntryPoint, then resolve it.
|
zJParameters to load are deprecated. Call .resolve and .require separately.rC rÏ )r r r rP r )r rP r> Úkwargsr r r rú s ü zEntryPoint.loadc
|
C sZ t | jdgdd}zt t| j|¡W S tk
|
rT } ztt||W 5 d}~X Y nX dS )zD
|
Resolve the entry point from its module and attrs.
|
r r )ÚfromlistÚlevelN) r´ r¸ Ú functoolsÚreducerµ rº r. r r± )r r¸ r· r r r r s
|
zEntryPoint.resolvec C sL | j r| jstd| | j | j ¡}tj|||| j d}tttj| d S )Nz&Can't require() without a distribution)r* ) r* r rn r r_ r r" r r
|
)r r. r/ r r* r r r rP © s
|
|
zEntryPoint.requirez]\s*(?P<name>.+?)\s*=\s*(?P<module>[\w.]+)\s*(:\s*(?P<attr>[\w.]+))?\s*(?P<extras>\[.*\])?\s*$c C sf | j |¡}|s d}t||| ¡ }| |d ¡}|d rJ|d d¡nd}| |d |d |||S )a Parse a single entry point from string `src`
|
|
Entry point syntax follows the form::
|
|
name = some.module:some.attr [extra1, extra2]
|
|
The entry name and module name are required, but the ``:attrs`` and
|
``[extras]`` parts are optional
|
z9EntryPoint must be in 'name=module:attrs [extras]' formatr* ÚattrrB r rä r¸ )ÚpatternrF rL Ú groupdictÚ _parse_extrasr )r Úsrcr rN r Úresr* rº r r r ræ ¿ s
|
zEntryPoint.parsec C s( |sdS t d| ¡}|jr"t |jS )Nr Úx)ri ræ ÚspecsrL r* )r Ú extras_specr r r r rÆ Ó s zEntryPoint._parse_extrasc C sV t |std|i }t|D ]2}| ||¡}|j|krFtd||j|||j< q |S )zParse an entry point groupzInvalid group namezDuplicate entry point)r· rL ru ræ rä )r rK Úlinesr Úthisrx Úepr r r Ú parse_groupÜ s
|
|
zEntryPoint.parse_groupc C st t |tr| ¡ }nt|}i }|D ]J\}}|dkrB|s:q$td| ¡ }||kr\td|| |||¡||< q$|S )z!Parse a map of entry point groupsNz%Entry points must be listed in groupszDuplicate group name)r¯ r$ r* rv rL rw rÏ )r Údatar ÚmapsrK rÌ r r r Ú parse_mapé s
|
|
|
zEntryPoint.parse_map)r r N)T)NN)N)N)N)r r r r r r© r rú r rP r rÀ rÄ rG ræ rÆ rÏ rÒ r r r r rj y s$
|
|
|
|
ÿ
|
c C s@ dd }t || }tt|d}| d¡\}}}t| ¡ p>dS )z
|
Given an iterable of lines from a Metadata file, return
|
the value of the Version field, if present, or None otherwise.
|
c S s | ¡ d¡S )Nzversion:)rW rÑ )rx r r r Úis_version_line
|
s z+_version_from_file.<locals>.is_version_linerº r» N)r rÞ ri Ú partitionrr rw )rÌ rÓ Ú version_linesrx rÏ r¶ r r r Ú_version_from_fileý s
|
|
rÖ c s e Zd ZdZdZddddedefddZedSddZ dd Z
|
e d
|
d Z d d Z dd Zdd Zdd Zdd Zdd Zdd Ze dd Ze d d Zd d Ze d d! Ze d"d# Zed$d% Zd&d' ZdTd)d*Z d+d, Z d-d. Z d/d0 Z dUd2d3Z d4d5 Z!d6d7 Z"d8d9 Z#d:d; Z$ fd<d=Z%e&e'd>s4[%edVd?d@Z(dAdB Z)dCdD Z*dWdEdFZ+dGdH Z,dXdIdJZ-dKdL Z.dMdN Z/dOdP Z0e dQdR Z1 Z2S )Yrh z5Wrap an actual or potential sys.path entry w/metadatar4 Nc C sF t |pd| _|d k r t|| _|| _|| _|| _|| _|p>t| _ d S )NÚUnknown)
|
rq r, rr Ú_versionrS rH r ru r Ú _provider)r r r8 r, r rS rH ru r r r r
|
s
|
zDistribution.__init__c K s~ d gd \}}}}t j |¡\}} | ¡ tkr^t| ¡ } t|}
|
|
|
r^|
|
dddd¡\}}}}| ||f||||d| ¡ S )NrÍ rä ÚverÚpyverrM )r, r rS rH )r¾ r¿ rR rW Ú_distributionImplÚEGG_NAMErK Ú_reload_version) r r râ r8 r' r, r rS rH rU rF r r r rK
|
s. ÿ ÿ þþzDistribution.from_locationc C s | S r r r r r r rÞ ,
|
s z Distribution._reload_versionc C s$ | j | j| j| j| jpd| jp dfS rð )Úparsed_versionru r8 r rS rH r r r r rZ /
|
s úzDistribution.hashcmpc C s
|
t | jS r )ÚhashrZ r r r r Ú__hash__:
|
s zDistribution.__hash__c C s | j |j k S r ©rZ ©r rc r r r Ú__lt__=
|
s zDistribution.__lt__c C s | j |j kS r râ rã r r r Ú__le__@
|
s zDistribution.__le__c C s | j |j kS r râ rã r r r Ú__gt__C
|
s zDistribution.__gt__c C s | j |j kS r râ rã r r r Ú__ge__F
|
s zDistribution.__ge__c C s t || jsdS | j|jkS rï )r¯ r rZ rã r r r Ú__eq__I
|
s zDistribution.__eq__c C s
|
| |k S r r rã r r r Ú__ne__O
|
s zDistribution.__ne__c C s6 z| j W S tk
|
r0 | j ¡ | _ }| Y S X d S r )Ú_keyr. r, rW rb r r r r8 V
|
s
|
zDistribution.keyc C s t | dst| j| _| jS )NÚ_parsed_version)rÁ r r rë r r r r rß ^
|
s
|
zDistribution.parsed_versionc C sX t jj}t| j|}|s d S | js&d S t d¡ ¡ dd¡}t
|
|j f t | t ¡ d S )Na>
|
'{project_name} ({version})' is being parsed as a legacy,
|
non PEP 440,
|
version. You may find odd behavior and sort order.
|
In particular it will be sorted as less than 0.0. It
|
is recommended to migrate to PEP 440 compatible
|
versions.
|
r» rÎ )r r r r¯ rë ro rp rw rÓ r r r Úvarsr )r ÚLVÚ is_legacyru r r r Ú_warn_legacy_versione
|
s ù z!Distribution._warn_legacy_versionc
|
C sn z| j W S tk
|
rh } zB| ¡ }|d krP| | j¡}d | j|¡}t|| || W Y ¢S d }~X Y nX d S )Nz4Missing 'Version:' header and/or {} file at path: {})rØ r. Ú _get_versionÚ _get_metadata_path_for_displayÚPKG_INFOr rL )r r r r¿ r r r r r
|
s ÿ þ zDistribution.versionc C s4 z| j W S tk
|
r, | | ¡ ¡| _ Y nX | j S )z~
|
A map of extra to its list of (direct) requirements
|
for this distribution, including the null extra.
|
)Ú_Distribution__dep_mapr. Ú_filter_extrasÚ_build_dep_mapr r r r Ú_dep_map
|
s
|
zDistribution._dep_mapc C sr t td| D ]^}|}| |¡}| d¡\}}}|oDt|pDt| }|rNg }t|pXd}| |g ¡ |¡ q| S )z¤
|
Given a mapping of extras to dependencies, strip off
|
environment markers and filter out any dependencies
|
not matching the markers.
|
Nr» ) r" r r' rÔ ry rz rw r r+ )ÚdmrH Ú new_extrar rÏ rJ Ú fails_markerr r r rô
|
s
|
þ zDistribution._filter_extrasc C s@ i }dD ]2}t | |¡D ] \}}| |g ¡ t|¡ qq|S )N)z requires.txtz depends.txt)rv Ú _get_metadatar r+ rp )r r÷ rä rH r r r r rõ °
|
s
|
zDistribution._build_dep_mapr c C sv | j }g }| | dd¡¡ |D ]P}z| |t| ¡ W q tk
|
rn } ztd| |f |W 5 d}~X Y q X q |S )z@List of Requirements needed for this distro if `extras` are usedNr z %s has no such extra feature %r)rö r+ rÊ rw r³ rn )r r* r÷ ÚdepsrU r r r r r ·
|
s
|
ÿþzDistribution.requiresc C s, z| j |¡}W n tk
|
r& Y dS X |S )zK
|
Return the path to the given metadata file, if available.
|
z[could not detect])rÙ r¯ ry r° r r r rñ Å
|
s
|
z+Distribution._get_metadata_path_for_displayc c s$ | |¡r | |¡D ]
|
}|V qd S r )rí rï )r rä rx r r r rú Ö
|
s
|
zDistribution._get_metadatac C s | | j¡}t|}|S r )rú rò rÖ )r rÌ r r r r rð Û
|
s zDistribution._get_versionFc C sV |dkrt j}| j||d |t jkrRt| j | d¡D ]}|t jkr:t| q:dS )z>Ensure distribution is importable on `path` (default=sys.path)Nr únamespace_packages.txt)rG r¿ r r r rú r² r^ )r r¿ rÓ Úpkgr r r Úactivateá
|
s
|
|
|
zDistribution.activatec C s8 dt | jt | j| jptf }| jr4|d| j 7 }|S )z@Return what this distribution's standard .egg filename should bez
|
%s-%s-py%sr )rx r, r rS ri rH )r r r r r rÙ ì
|
s þzDistribution.egg_namec C s | j rd| | j f S t| S d S )Nz%s (%s))r r± r r r r r ÷
|
s zDistribution.__repr__c C s@ zt | dd }W n tk
|
r( d }Y nX |p0d}d| j|f S )Nr z[unknown version]z%s %s)rµ rL r, )r r r r r r© ý
|
s
|
zDistribution.__str__c C s | d¡rt|t| j|S )zADelegate all unrecognized public attributes to .metadata providerrÏ )rÑ r. rµ rÙ )r rà r r r Ú __getattr__ s
|
zDistribution.__getattr__c s. t ttt| ¡ tdd | j ¡ D B S )Nc s s | ]}| d ¡s|V qdS ©rÏ N)rÑ )r rà r r r r s
|
ÿz'Distribution.__dir__.<locals>.<genexpr>)r" r& Úsuperrh Ú__dir__rÙ r rf r r r s ÿÿÿzDistribution.__dir__r c K s | j t|tj |¡|f|S r )rK r[ r¾ r¿ râ )r r r8 r' r r r rG s
|
ÿþzDistribution.from_filenamec C s< t | jtjjr"d| j| jf }nd| j| jf }t |¡S )z?Return a ``Requirement`` that matches this distribution exactlyz%s==%sz%s===%s)r¯ rß r r r r, ri ræ )r Úspecr r r r8 s zDistribution.as_requirementc C s. | ||¡}|dkr&td||ff | ¡ S )z=Return the `name` entry point of `group` or raise ImportErrorNzEntry point %r not found)rV r rú )r rK rä rÎ r r r rT ( s z Distribution.load_entry_pointc C sP z
|
| j }W n, tk
|
r6 t | d¡| ¡ }| _ Y nX |dk rL| |i ¡S |S )rê zentry_points.txtN)Ú_ep_mapr. rj rÒ rú rÊ )r rK Úep_mapr r r rU / s
|
ÿ zDistribution.get_entry_mapc C s | |¡ |¡S rë )rU rÊ r r r r rV ; s zDistribution.get_entry_infoc
|
C s4 |p| j }|sdS t|}tj |¡}dd |D }t|D ]|\}}||kr^|rV qìq¸ dS q<||kr<| jtkr<|s|||d
kr dS |tjkr| ¡ |
|
||¡ |
|
||¡ qìq<|tjkrÌ| ¡ |rÞ|
|
d|¡ n
|
| |¡ dS z| ||d ¡} W n t k
|
r Y q0Y qìX || = || = | }qìdS )aä Ensure self.location is on path
|
|
If replace=False (default):
|
- If location is already in path anywhere, do nothing.
|
- Else:
|
- If it's an egg and its parent directory is on path,
|
insert just ahead of the parent.
|
- Else: add to the end of path.
|
If replace=True:
|
- If location is already on path anywhere (not eggs)
|
or higher priority than its parent (eggs)
|
do nothing.
|
- Else:
|
- If it's an egg and its parent directory is on path,
|
insert just ahead of the parent,
|
removing any lower-priority entries.
|
- Else: add it to the front of path.
|
Nc S s g | ]}|rt |p|qS r r r r r r rQ Y s z*Distribution.insert_on.<locals>.<listcomp>r r )r r[ r¾ r¿ r£ Ú enumerateru r} rG Úcheck_version_conflictr rà r rL )
|
r r¿ ÚlocrÓ ÚnlocÚbdirÚnpathr r Únpr r r r ? s@
|
|
|
|
zDistribution.insert_onc C s¨ | j dkrd S t | d¡¡}t| j}| d¡D ]p}|tjks2||ks2|tkrRq2|dkr\q2t tj| dd }|rt|
|
|¡s2|
|
| j¡rq2t d||| jf q2d S )NÚ
|
setuptoolsrü z top_level.txt)Ú pkg_resourcesr Úsiter¢ zIModule %s was already imported from %s, but %s is being added to sys.path) r8 r$ r% rú r| r rG r² r rµ rÑ Ú issue_warning)r Únspr ÚmodnameÚfnr r r r s*
|
|
ÿ
|
ÿ
|
ÿÿz#Distribution.check_version_conflictc C s6 z
|
| j W n& tk
|
r0 tdt| Y dS X dS )NzUnbuilt egg for FT)r rL r r r r r r r] s
|
zDistribution.has_versionc K s@ d}| ¡ D ]}| |t| |d¡ q | d| j¡ | jf |S )z@Copy this distribution, substituting in any changed keyword argsz<project_name version py_version platform location precedenceNr8 )r r rµ rÙ r )r r' r| rà r r r Úclone¡ s
|
zDistribution.clonec C s dd | j D S )Nc S s g | ] }|r|qS r r )r Údepr r r rQ « s z'Distribution.extras.<locals>.<listcomp>)rö r r r r r* © s zDistribution.extras)N)r )NF)N)N)NF)3r r r r rò ri r} r rG rK rÞ r¦ rZ rá rä rå ræ rç rè ré r8 rß rï r rö r rô rõ r rñ rú rð rþ rÙ r r© rÿ r rÁ ÚobjectrG r8 rT rU rV r r r] r r* Ú __classcell__r r rf r rh
|
|
st ý
|
|
|
|
|
|
|
|
|
|
|
|
Dc @ s e Zd Zdd ZdS )ÚEggInfoDistributionc C s | ¡ }|r|| _| S )añ
|
Packages installed by distutils (e.g. numpy or scipy),
|
which uses an old safe_version, and so
|
their version numbers can get mangled when
|
converted to filenames (e.g., 1.11.0.dev0+2329eae to
|
1.11.0.dev0_2329eae). These distributions will not be
|
parsed properly
|
downstream by Distribution and safe_version, so
|
take an extra step and try to get the version number from
|
the metadata file itself instead of the filename.
|
)rð rØ )r Ú
|
md_versionr r r rÞ ¯ s z#EggInfoDistribution._reload_versionN)r r r rÞ r r r r r ® s r c @ s> e Zd ZdZdZe d¡Zedd Z edd Z
|
dd Z d
|
S ) ÚDistInfoDistributionzV
|
Wrap an actual or potential sys.path entry
|
w/metadata, .dist-info style.
|
ÚMETADATAz([\(,])\s*(\d.*?)\s*([,\)])c C sF z| j W S tk
|
r@ | | j¡}tj ¡ |¡| _ | j Y S X dS )zParse and cache metadataN)Ú _pkg_infor. rî rò ÚemailÚparserÚParserÚparsestr)r r8 r r r Ú_parsed_pkg_infoÉ s z%DistInfoDistribution._parsed_pkg_infoc C s2 z| j W S tk
|
r, | ¡ | _ | j Y S X d S r )Ú _DistInfoDistribution__dep_mapr. Ú_compute_dependenciesr r r r rö Ó s
|
|
z DistInfoDistribution._dep_mapc s dg i }| _ g | j d¡p g D ]} t|¡ q" fdd}t|d}|d |¡ | j d¡pjg D ](}t| ¡ }tt||| ||< ql|S )z+Recompute this distribution's dependencies.Nz Requires-Distc 3 s* D ] }|j r |j d| i¡r|V qd S )NrH rI )rH r ©r r r Úreqs_for_extraä s zBDistInfoDistribution._compute_dependencies.<locals>.reqs_for_extrazProvides-Extra) r" r! Úget_allr+ rp Ú frozensetrw rw r" )r r÷ r r% ÚcommonrH Ús_extrar r$ r r# Û s z*DistInfoDistribution._compute_dependenciesN) r r r r rò r rÀ ÚEQEQr¦ r! rö r# r r r r r Á s
|
|
|
r )r° rc rE c O sZ d}t }z t |¡j|kr&|d7 }q W n tk
|
r< Y nX tj| d|d i| d S )Nr rÐ )r! rG rà rá rL r r )r> r' rÀ r- r r r r ú s r c c s t t| }|D ]l}d|kr.|d| d¡
}| d¡rr|dd
¡ }z|t|7 }W n tk
|
rp Y dS X t|V qdS )zYield ``Requirement`` objects for each specification in `strs`
|
|
`strs` must be a string, or a (possibly-nested) iterable thereof.
|
z #Nú\éþÿÿÿ)ri ru r° rF rw rÞ Ú StopIterationri )r´ rÌ rx r r r rp s
|
|
c @ s e Zd ZdZdS )ÚRequirementParseErrorz,Compatibility wrapper for InvalidRequirementNr r r r r r. s r. c sP e Zd Z fddZdd Zdd Zdd Zd d
|
Zd d Ze d d Z
|
Z S )ri c s t t| |¡ | j| _t| j}|| ¡ | _| _dd | j D | _
|
t t t | j| _| j| j| j t| j| jr|t| jndf| _t| j| _dS )z>DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!c S s g | ]}|j |jfqS r )r^ r )r r r r r rQ ( s z(Requirement.__init__.<locals>.<listcomp>N)r ri r rä Ú unsafe_namerq rW r, r8 Ú specifierrÊ r¹ r rw r* Úurlr' rJ r± ÚhashCmprà Ú_Requirement__hash)r Úrequirement_stringr, rf r r r " s
|
ÿûzRequirement.__init__c C s t |to| j|jkS r )r¯ ri r2 rã r r r rè 4 s
|
|
þzRequirement.__eq__c C s
|
| |k S r r rã r r r ré : s zRequirement.__ne__c C s0 t |tr |j| jkrdS |j}| jj|ddS )NFT)Ú prereleases)r¯ rh r8 r r0 Úcontains)r r r r r r = s
|
|
zRequirement.__contains__c C s | j S r )r3 r r r r rá I s zRequirement.__hash__c C s dt | S )NzRequirement.parse(%r)r½ r r r r r L s zRequirement.__repr__c C s t | \}|S r )rp )rµ r r r r ræ O s
|
zRequirement.parse) r r r r rè ré r rá r r ræ r r r rf r ri ! s c C s t | kr| t f S | S )zJ
|
Ensure object appears in the mro even
|
for old-style classes.
|
)r )Úclassesr r r Ú_always_objectU s
|
r8 c C s< t t t|dt|¡}|D ]}|| kr | | S q dS )z2Return an adapter factory for `ob` from `registry`r N)r8 ÚinspectÚgetmrorµ rë )Úregistryr9 r Útr r r r¶ _ s r¶ c C s t j | ¡}t j|dd dS )z1Ensure that the parent directory of `path` existsT)Úexist_okN)r¾ r¿ r£ Úmakedirs)r¿ r£ r r r r{ g s c C sX t s tdt| \}}|rT|rTt|sTt| zt|d W n tk
|
rR Y nX dS )z/Sandbox-bypassing version of ensure_directory()z*"os.mkdir" not supported on this platform.ií N)r r r r rx r ÚFileExistsError)r¿ r£ r r r r rx m s rx c c sv d}g }t | D ]V}| d¡r\| d¡rP|s0|r:||fV |dd
¡ }g }qftd|q| |¡ q||fV dS )as Split a string or iterable thereof into (section, content) pairs
|
|
Each ``section`` is a stripped version of the section header ("[section]")
|
and each ``content`` is a list of stripped lines excluding blank lines and
|
comment-only lines. If there are any such lines before the first section
|
header, they're returned in a first ``section`` of ``None``.
|
Nú[ú]r rª zInvalid section heading)ru rÑ rF rw rL rà )rµ ÚsectionÚcontentrx r r r rv z s
|
|
|
c O s* t j}ztt _tj| |W ¢S |t _X d S r )r¾ r Úos_openÚtempfileÚmkstemp)r> r' Úold_openr r r r s
|
r r )Úcategoryrà c O s | || | S r r )r+ r> r¾ r r r Ú _call_aside§ s
|
rI c s. t | d< | fddt D ¡ dS )z=Set up global resource manager (deliberately not state-saved)Ú_managerc 3 s& | ] }| d ¡s|t |fV qdS r )rÑ rµ ró ©rô r r r ± s
|
þz _initialize.<locals>.<genexpr>N)rg r" r )r- r rK r Ú _initialize¬ s
|
þrL c C s| t ¡ } td| d | j}| j}| j}| j}|}tdd | D |dd dd g | _t t
|
| j t j t t ¡ d S )
|
aE
|
Prepare the master working set and make the ``require()``
|
API available.
|
|
This function has explicit effects on the global state
|
of pkg_resources. It is intended to be invoked once at
|
the initialization of this module.
|
|
Invocation by other packages is unsupported and done
|
at their own risk.
|
r )r_ c s s | ]}|j d dV qdS )Fr N©rþ )r r r r r r Ò s ÿz1_initialize_master_working_set.<locals>.<genexpr>c S s | j ddS )NTr rM rè r r r r? × r@ z0_initialize_master_working_set.<locals>.<lambda>F)rD N)rf r r( rP rW rE rQ r¹ rû r" r rÿ rG r¿ r! r" r¡ )r_ rP rW r` rQ r r r r Ú _initialize_master_working_set¸ s" þþrN c @ s e Zd ZdZdS )r z«
|
Base class for warning about deprecations in ``pkg_resources``
|
|
This class is not derived from ``DeprecationWarning``, and as such is
|
visible by default.
|
Nr r r r r r à s )N)N)F)F)F)F)N)Ør Ú
|
__future__r rG r¾ r¨ r r r rö rI r r rÁ Úpkgutilr^ rH r$ rÂ Ú email.parserr rp rE ro rS r9 rÕ rÒ r r¡ r Úimpr? Ú NameErrorro Zpkg_resources.externr Z pkg_resources.extern.six.movesr r r r r r
|
r r rD Úos.pathr r Úimportlib.machineryÚ machineryrê r r r r´ rë Ú __metaclass__Ú version_infoÚ RuntimeErrorr² rm rn rP r_ r` Úresources_streamrc Ú resource_dirrY rb r] rX rW r[ rZ r\ r> r r ÚRuntimeWarningr r r# r( r/ r1 r5 r: r; r< Ú
|
_sget_noneÚ
|
_sset_nonerO Ú__all__ry rk rl r£ rm rn r« r ri r} r~ r r r r rR rJ rÌ rD rÀ rE r× rs rt rQ r rS rT rU rV r r rf r$ r# re r ro rg rd rq rr rw rx ry rz r r rÛ r r rî r r rñ rû r rJ r r
r r ra rH rO rX rb rY rf r] rd ry re Ú ImpImporterrÁ r~ r r r r^ r r§ r¨ r| r« r[ rÝ r\ r ru rF r· ÚVERBOSEÚ
|
IGNORECASErÝ rj rÖ rh r r rÜ r rp r- ÚInvalidRequirementr. ri r8 r¶ r{ rx rv r ÚfilterwarningsrI r! rL rN ÚWarningr r r r r Ú<module> sX
|
|
|
|
Ò2
|
|
|
.
|
|
6 B
|
- *
|
|
#""
|
|
|
ö '3ý 4
|
|
'
|
