3
Pf @ s d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl m
Z
mZ ddlmZ ddlmZmZ ddlmZmZmZ dd lmZmZmZm Z m Z m Z m Z d
d d d
dgZ ej!e"Z#dZ$dZ%deddde$dfZ&dZ'G dd de(Z)G dd de(Z*G dd
d
e(Z+G dd d e+Z,G d d d e,Z-G d d
d
e,Z.e-Z/e.Z0G d d d e(Z1d)d!d"Z2d#d$ Z3d%d& Z4d'd( Z5dS )*zPEP 376 implementation. )unicode_literalsN )DistlibException resources)StringIO)
get_schemeUnsupportedVersionError)MetadataMETADATA_FILENAMEWHEEL_METADATA_FILENAME)parse_requirementcached_propertyparse_name_and_version read_exports
write_exports CSVReader CSVWriter DistributionBaseInstalledDistributionInstalledDistributionEggInfoDistributionDistributionPathzpydist-exports.jsonzpydist-commands.jsonZ INSTALLERRECORD REQUESTED RESOURCESSHAREDz
.dist-infoc @ s( e Zd ZdZdd Zdd Zdd ZdS ) _CachezL
A simple cache mapping names and .dist-info paths to distributions
c C s i | _ i | _d| _dS )zZ
Initialise an instance. There is normally one for each DistributionPath.
FN)namepath generated)self r! /usr/lib/python3.6/database.py__init__0 s z_Cache.__init__c C s | j j | jj d| _dS )zC
Clear the cache, setting it to its initial state.
FN)r clearr r )r r! r! r" r$ 8 s
z _Cache.clearc C s2 |j | j kr.|| j |j < | jj|jg j| dS )z`
Add a distribution to the cache.
:param dist: The distribution to add.
N)r r
setdefaultkeyappend)r distr! r! r" add@ s z
_Cache.addN)__name__
__module__ __qualname____doc__r# r$ r) r! r! r! r" r , s r c @ s e Zd ZdZd ddZdd Zdd ZeeeZd
d Z d d
Z
dd Z e dd Z
dd Zdd Zd ddZdd Zd ddZdS ) r zU
Represents a set of distributions installed on a path (typically sys.path).
NFc C sD |dkrt j}|| _d| _|| _t | _t | _d| _td| _ dS )a
Create an instance from a path, optionally including legacy (distutils/
setuptools/distribute) distributions.
:param path: The path to use, as a list of directories. If not specified,
sys.path is used.
:param include_egg: If True, this instance will look for and return legacy
distributions as well as those based on PEP 376.
NTdefault)
sysr
_include_dist _include_eggr _cache
_cache_egg_cache_enabledr _scheme)r r Z include_eggr! r! r" r# N s zDistributionPath.__init__c C s | j S )N)r4 )r r! r! r" _get_cache_enabledb s z#DistributionPath._get_cache_enabledc C s
|| _ d S )N)r4 )r valuer! r! r" _set_cache_enablede s z#DistributionPath._set_cache_enabledc C s | j j | jj dS )z,
Clears the internal cache.
N)r2 r$ r3 )r r! r! r" clear_cachej s
z DistributionPath.clear_cachec
c sT t }xF| jD ]:}tj|}|dkr*q|jd}| s|j rDqt|j} x|D ]}|j|}| sV|j|krvqV| jo|jt rt
t g}x*|D ] }t j
||} |j| }
|
rP qW qVtj|
j } t| dd} W dQ R X tjd|j |j|j t|j| | dV qV| jrV|jd rVtjd|j |j|j t|j| V qVW qW dS )
zD
Yield .dist-info and/or .egg(-info) distributions.
N legacy)fileobjschemezFound %s)metadataenv .egg-info.egg)r@ rA )setr r finder_for_pathfindZ is_containersortedr0 endswith DISTINFO_EXTr
r posixpathjoin
contextlibclosing as_streamr loggerdebugr) new_dist_classr1 old_dist_class)
r seenr finderrZrsetentryZpossible_filenamesZmetadata_filenameZ
metadata_pathZpydiststreamr> r! r! r" _yield_distributionsr s@
z%DistributionPath._yield_distributionsc C st | j j }| jo| jj }|s"|rpx4| j D ](}t|trH| j j| q,| jj| q,W |rdd| j _|rpd| j_dS )zk
Scan the path for distributions and populate the cache with
those that are found.
TN)r2 r r1 r3 rV
isinstancer r) )r Zgen_distZgen_eggr( r! r! r" _generate_cache s
z DistributionPath._generate_cachec C s |j dd}dj||gt S )ao
The *name* and *version* parameters are converted into their
filename-escaped form, i.e. any ``'-'`` characters are replaced
with ``'_'`` other than the one in ``'dist-info'`` and the one
separating the name from the version number.
:parameter name: is converted to a standard distribution name by replacing
any runs of non- alphanumeric characters with a single
``'-'``.
:type name: string
:parameter version: is converted to a standard version string. Spaces
become dots, and all other non-alphanumeric characters
(except dots) become dashes, with runs of multiple
dashes condensed to a single dash.
:type version: string
:returns: directory name
:rtype: string-_)replacerI rG )clsr versionr! r! r" distinfo_dirname s z!DistributionPath.distinfo_dirnamec c sj | j s x^| j D ]
}|V qW nF| j x| jjj D ]
}|V q6W | jrfx| jjj D ]
}|V qXW dS )a5
Provides an iterator that looks for distributions and returns
:class:`InstalledDistribution` or
:class:`EggInfoDistribution` instances for each one of them.
:rtype: iterator of :class:`InstalledDistribution` and
:class:`EggInfoDistribution` instances
N)r4 rV rX r2 r valuesr1 r3 )r r( r! r! r" get_distributions s
z"DistributionPath.get_distributionsc C s d}|j }| js6xj| j D ]}|j|kr |}P q W nH| j || jjkr\| jj| d }n"| jr~|| jjkr~| jj| d }|S )a=
Looks for a named distribution on the path.
This function only returns the first result found, as no more than one
value is expected. If nothing is found, ``None`` is returned.
:rtype: :class:`InstalledDistribution`, :class:`EggInfoDistribution`
or ``None``
Nr ) lowerr4 rV r& rX r2 r r1 r3 )r r resultr( r! r! r" get_distribution s
z!DistributionPath.get_distributionc c s d}|dk rJy| j jd||f }W n$ tk
rH td||f Y nX xd| j D ]X}|j}xL|D ]D}t|\}}|dkr||kr|V P qd||krd|j|rd|V P qdW qTW dS )a
Iterates over all distributions to find which distributions provide *name*.
If a *version* is provided, it will be used to filter the results.
This function only returns the first result found, since no more than
one values are expected. If the directory is not found, returns ``None``.
:parameter version: a version specifier that indicates the version
required, conforming to the format in ``PEP-345``
:type name: string
:type version: string
Nz%s (%s)z invalid name or version: %r, %r)r5 matcher
ValueErrorr r` providesr match) r r r] rd r( providedpp_namep_verr! r! r" provides_distribution s$
z&DistributionPath.provides_distributionc C s( | j |}|dkr td| |j|S )z5
Return the path to a resource file.
Nz no distribution named %r found)rc LookupErrorget_resource_path)r r
relative_pathr( r! r! r"
get_file_path s
z DistributionPath.get_file_pathc c s` xZ| j D ]N}|j}||kr
|| }|dk r@||krX|| V q
x|j D ]
}|V qJW q
W dS )z
Return all of the exported entries in a particular category.
:param category: The category to search for entries.
:param name: If specified, only entries with that name are returned.
N)r` exportsr_ )r categoryr r( rS dvr! r! r" get_exported_entries" s z%DistributionPath.get_exported_entries)NF)N)N)r* r+ r, r- r# r6 r8 propertyZ
cache_enabledr9 rV rX classmethodr^ r` rc rl rp ru r! r! r! r" r J s
*
$ c @ s e Zd ZdZdZdZdd Zedd ZeZ edd Z
ed d
Z d d Z ed
d Z
edd Zedd Zedd Zedd Zdd Zdd Zdd Zd d Zd S ) r z
A base class for distributions, whether installed or from indexes.
Either way, it must have some metadata, so that's all that's needed
for construction.
Fc C sL || _ |j| _| jj | _|j| _d| _d| _d| _d| _t | _
i | _ dS )z
Initialise an instance.
:param metadata: The instance of :class:`Metadata` describing this
distribution.
N) r> r ra r& r] ZlocatordigestextrascontextrB Z
download_urlsZdigests)r r> r! r! r" r# G s zDistribution.__init__c C s | j jS )zH
The source archive download URL for this distribution.
)r>
source_url)r r! r! r" r{ X s zDistribution.source_urlc C s d| j | jf S )zX
A utility property which displays the name and version in parentheses.
z%s (%s))r r] )r r! r! r" name_and_versiona s z Distribution.name_and_versionc C s. | j j}d| j| jf }||kr*|j| |S )z
A set of distribution names and versions provided by this distribution.
:return: A set of "name (version)" strings.
z%s (%s))r> rf r r] r' )r Zplistsr! r! r" rf h s
zDistribution.providesc C s8 | j }tjd|j t||}t|j|| j| jdS )Nz%Getting requirements from metadata %r)ry r? ) r> rM rN ZtodictgetattrrB Zget_requirementsry rz )r Zreq_attrmdZreqtsr! r! r" _get_requirementst s
z Distribution._get_requirementsc C s
| j dS )N run_requires)r )r r! r! r" r { s zDistribution.run_requiresc C s
| j dS )N
meta_requires)r )r r! r! r" r s zDistribution.meta_requiresc C s
| j dS )Nbuild_requires)r )r r! r! r" r s zDistribution.build_requiresc C s
| j dS )N
test_requires)r )r r! r! r" r s zDistribution.test_requiresc C s
| j dS )N dev_requires)r )r r! r! r" r s zDistribution.dev_requiresc
C s t |}t| jj}y|j|j}W n6 tk
rZ tjd| |j d }|j|}Y nX |j
}d}xJ| j D ]@}t |\}} ||krqny|j
| }P W qn tk
r Y qnX qnW |S )z
Say if this instance matches (fulfills) a requirement.
:param req: The requirement to match.
:rtype req: str
:return: True if it matches, else False.
z+could not read version %r - using name onlyr F)r r r> r= rd requirementr rM warningsplitr& rf r rg )
r reqrS r= rd r rb ri rj rk r! r! r" matches_requirement s*
z Distribution.matches_requirementc C s( | j rd| j }nd}d| j| j|f S )zC
Return a textual representation of this instance,
z [%s]r: z)r{ r r] )r suffixr! r! r" __repr__ s zDistribution.__repr__c C s> t |t | k rd}n$| j|jko8| j|jko8| j|jk}|S )a<
See if this distribution is the same as another.
:param other: The distribution to compare with. To be equal to one
another. distributions must have the same type, name,
version and source_url.
:return: True if it is the same, else False.
F)typer r] r{ )r otherrb r! r! r" __eq__ s zDistribution.__eq__c C s t | jt | j t | j S )zH
Compute hash in a way which matches the equality test.
)hashr r] r{ )r r! r! r" __hash__ s zDistribution.__hash__N)r* r+ r, r- Zbuild_time_dependency requestedr# rv r{ Z download_urlr| rf r r r r r r r r r r r! r! r! r" r 5 s$ "
c s0 e Zd ZdZdZd fdd ZdddZ ZS ) r z]
This is the base class for installed distributions (whether PEP 376 or
legacy).
Nc s t t| j| || _|| _dS )a
Initialise an instance.
:param metadata: An instance of :class:`Metadata` which describes the
distribution. This will normally have been initialised
from a metadata file in the ``path``.
:param path: The path of the ``.dist-info`` or ``.egg-info``
directory for the distribution.
:param env: This is normally the :class:`DistributionPath`
instance where this distribution was found.
N)superr r# r dist_path)r r> r r? ) __class__r! r" r# s z"BaseInstalledDistribution.__init__c C sd |dkr| j }|dkr"tj}d}ntt|}d| j }||j }tj|jdjd}d||f S )a
Get the hash of some data, using a particular hash algorithm, if
specified.
:param data: The data to be hashed.
:type data: bytes
:param hasher: The name of a hash implementation, supported by hashlib,
or ``None``. Examples of valid values are ``'sha1'``,
``'sha224'``, ``'sha384'``, '``sha256'``, ``'md5'`` and
``'sha512'``. If no hasher is specified, the ``hasher``
attribute of the :class:`InstalledDistribution` instance
is used. If the hasher is determined to be ``None``, MD5
is used as the hashing algorithm.
:returns: The hash of the data. If a hasher was explicitly specified,
the returned hash will be prefixed with the specified hasher
followed by '='.
:rtype: str
Nr: z%s= =asciiz%s%s) hasherhashlibmd5r~ rx base64Zurlsafe_b64encoderstripdecode)r datar prefixrx r! r! r" get_hash s
z"BaseInstalledDistribution.get_hash)N)N)r* r+ r, r- r r# r
__classcell__r! r! )r r" r s c s e Zd ZdZdZd' fdd Zdd Zdd Zd
d Ze d d
Z
dd Z dd Z dd Z
dd Zd(ddZdd Ze dd Zd)d d Zd d Zd!d" Zd#d$ Zd%d& ZejZ ZS )*r a
Created with the *path* of the ``.dist-info`` directory provided to the
constructor. It reads the metadata contained in ``pydist.json`` when it is
instantiated., or uses a passed in Metadata instance (useful for when
dry-run mode is being used).
Zsha256Nc s0 t j| | _}|d kr(dd l}|j |rN|jrN||jjkrN|jj| j}nt|d kr|j t
}|d krr|j t }|d kr|j d}|d krt dt
|f t
j|j }t|dd}W d Q R X tt| j||| |r|jr|jj| y|j d}W n& tk
r dd l}|j Y nX |d k | _d S )Nr ZMETADATAzno %s found in %sr; )r< r= r )r rC rR pdbZ set_tracer4 r2 r r> rD r
r re rJ rK rL r r r r# r) AttributeErrorr )r r r> r? rR r rS rU )r r! r" r# s4
z InstalledDistribution.__init__c C s d| j | j| jf S )Nz#)r r] r )r r! r! r" r 2 s z InstalledDistribution.__repr__c C s d| j | jf S )Nz%s %s)r r] )r r! r! r" __str__6 s z InstalledDistribution.__str__c
C s g }| j d}tj|j `}t|dJ}xB|D ]:}dd tt|dD }|| \}}} |j||| f q0W W dQ R X W dQ R X |S )a"
Get the list of installed files for the distribution
:return: A list of tuples of path, hash and size. Note that hash and
size might be ``None`` for some entries. The path is exactly
as stored in the file (which is as in PEP 376).
r )rU c S s g | ]}d qS )Nr! ).0ir! r! r"
H s z6InstalledDistribution._get_records.. N)get_distinfo_resourcerJ rK rL r rangelenr' )
r resultsrS rU Z
record_readerrowmissingr checksumsizer! r! r" _get_records9 s
(z"InstalledDistribution._get_recordsc C s i }| j t}|r| j }|S )a
Return the information exported by this distribution.
:return: A dictionary of exports, mapping an export category to a dict
of :class:`ExportEntry` instances describing the individual
export entries, and keyed by name.
)r EXPORTS_FILENAMEr )r rb rS r! r! r" rq P s
z InstalledDistribution.exportsc C s8 i }| j t}|r4tj|j }t|}W dQ R X |S )z
Read exports data from a file in .ini format.
:return: A dictionary of exports, mapping an export category to a list
of :class:`ExportEntry` instances describing the individual
export entries.
N)r r rJ rK rL r )r rb rS rU r! r! r" r ^ s
z"InstalledDistribution.read_exportsc
C s. | j t}t|d}t|| W dQ R X dS )a
Write a dictionary of exports to a file in .ini format.
:param exports: A dictionary of exports, mapping an export category to
a list of :class:`ExportEntry` instances describing the
individual export entries.
wN)get_distinfo_filer openr )r rq Zrffr! r! r" r m s
z#InstalledDistribution.write_exportsc C sh | j d}tj|j :}t|d$}x |D ]\}}||kr,|S q,W W dQ R X W dQ R X td| dS )aW
NOTE: This API may change in the future.
Return the absolute path to a resource file with the given relative
path.
:param relative_path: The path, relative to .dist-info, of the resource
of interest.
:return: The absolute path where the resource is to be found.
r )rU Nz3no resource file with relative path %r is installed)r rJ rK rL r KeyError)r ro rS rU Zresources_readerZrelativeZ destinationr! r! r" rn x s
z'InstalledDistribution.get_resource_pathc c s x| j D ]
}|V q
W dS )z
Iterates over the ``RECORD`` entries and returns a tuple
``(path, hash, size)`` for each line.
:returns: iterator of (path, hash, size)
N)r )r rb r! r! r" list_installed_files s z*InstalledDistribution.list_installed_filesFc C s, t jj|d}t jj| j}|j|}t jj|d}| jd}tjd| |rRdS t|}x|D ]}t jj |s||j
d rd } }
n4dt jj | }
t |d} | j
| j } W dQ R X |j|s|r|j|rt jj||}|j|| |
f qbW |j|rt jj||}|j|ddf W dQ R X |S )
z
Writes the ``RECORD`` file, using the ``paths`` iterable passed in. Any
existing ``RECORD`` file is silently overwritten.
prefix is used to determine when to write absolute paths.
r: r z creating %sN.pyc.pyoz%drb)r r )osr rI dirname
startswithr rM infor isdirrF getsizer r readrelpathZwriterow) r pathsr dry_runbaseZbase_under_prefix record_pathwriterr
hash_valuer fpr! r! r" write_installed_files s.
z+InstalledDistribution.write_installed_filesc
C s g }t jj| j}| jd} x| j D ]\}}}t jj|sLt jj||}||krVq(t jj|sv|j|dddf q(t jj |r(t
t jj |}|r||kr|j|d||f q(|r(d|kr|j ddd }nd }t
|d
2} | j| j |}
|
|kr |j|d ||
f W d Q R X q(W |S ) a
Checks that the hashes and sizes of the files in ``RECORD`` are
matched by the files themselves. Returns a (possibly empty) list of
mismatches. Each entry in the mismatch list will be a tuple consisting
of the path, 'exists', 'size' or 'hash' according to what didn't match
(existence is checked first, then size, then hash), the expected
value and the actual value.
r existsTFr =r r Nr r )r r r r r isabsrI r r' isfilestrr r r r r ) r
mismatchesr r r r r Z actual_sizer r Z actual_hashr! r! r" check_installed_files s.
z+InstalledDistribution.check_installed_filesc C s i }t jj| jd}t jj|rtj|ddd}|j j }W dQ R X x@|D ]8}|jdd\}}|dkr~|j |g j
| qN|||< qNW |S ) a
A dictionary of shared locations whose keys are in the set 'prefix',
'purelib', 'platlib', 'scripts', 'headers', 'data' and 'namespace'.
The corresponding value is the absolute path of that category for
this distribution, and takes into account any paths selected by the
user at installation time (e.g. via command-line arguments). In the
case of the 'namespace' key, this would be a list of absolute paths
for the roots of namespace packages in this distribution.
The first time this property is accessed, the relevant information is
read from the SHARED file in the .dist-info directory.
r rS zutf-8)encodingNr r namespace) r r rI r codecsr r
splitlinesr r% r' )r rb shared_pathr linesliner& r7 r! r! r" shared_locations s
z&InstalledDistribution.shared_locationsc
C s t jj| jd}tjd| |r$dS g }x6dD ].}|| }t jj|| r.|jd ||f q.W x"|jd
f D ]}|jd | qnW tj |d d
d}|j
dj| W dQ R X |S )aa
Write shared location information to the SHARED file in .dist-info.
:param paths: A dictionary as described in the documentation for
:meth:`shared_locations`.
:param dry_run: If True, the action is logged but no file is actually
written.
:return: The path of the file written to.
r z creating %sNr libheadersscriptsr z%s=%sr z namespace=%sr zutf-8)r
)r r r r r ) r r rI rM r r r' getr r write) r r r r r r& r nsr r! r! r" write_shared_locations s
z,InstalledDistribution.write_shared_locationsc C sF |t krtd|| jf tj| j}|d kr.set_name_and_version) r r r4 r3 r> r r]
_get_metadatar) r r r# )r r r? r r> )r r! r" r# W s
z EggInfoDistribution.__init__c
s2 d }dd fdd}|j drtjj|rdtjj|dd}t|dd }tjj|dd
}||}n`tj|}t|j d j
d }t|dd
}y |j d} | j
d}W n t k
r d }Y nX nX|j drtjj|rtjj|d
}||}tjj|d}t|dd }n t d| |r.|j
| |S )Nc S s g }| j }x|D ]}|j }|jdr6tjd| P t|}|sPtjd| q|jr`tjd |jst|j|j qdj
dd |jD }|jd|j |f qW |S ) zCreate a list of dependencies from a requires.txt file.
*data*: the contents of a setuptools-produced requires.txt file.
[z.Unexpected line: quitting requirement scan: %rz#Not recognised as a requirement: %rz4extra requirements in requires.txt are not supportedz, c s s | ]}d | V qdS )z%s%sNr! )r cr! r! r" s zQEggInfoDistribution._get_metadata..parse_requires_data..z%s (%s)) r stripr rM r r ry Z constraintsr' r rI )r reqsr r rS Zconsr! r! r" parse_requires_datao s&
z>EggInfoDistribution._get_metadata..parse_requires_datac sH g }y*t j| dd} |j }W dQ R X W n tk
rB Y nX |S )zCreate a list of dependencies from a requires.txt file.
*req_path*: the path to a setuptools-produced requires.txt file.
rS zutf-8N)r r r IOError)req_pathr r )r r! r" parse_requires_path s z>EggInfoDistribution._get_metadata..parse_requires_pathz.eggzEGG-INFOzPKG-INFOr; )r r= z requires.txtzEGG-INFO/PKG-INFOutf8)r< r= zEGG-INFO/requires.txtzutf-8z .egg-infoz,path must end with .egg-info or .egg, got %r)rF r r r rI r zipimport zipimporterr get_datar r r Zadd_requirements)
r r requiresr meta_pathr> r Zzipfr< r r! )r r" r l s:
z!EggInfoDistribution._get_metadatac C s d| j | j| jf S )Nz!)r r] r )r r! r! r" r s z EggInfoDistribution.__repr__c C s d| j | jf S )Nz%s %s)r r] )r r! r! r" r s zEggInfoDistribution.__str__c C sd g }t jj| jd}t jj|r`x>| j D ]2\}}}||kr>q*t jj|s*|j|dddf q*W |S )a
Checks that the hashes and sizes of the files in ``RECORD`` are
matched by the files themselves. Returns a (possibly empty) list of
mismatches. Each entry in the mismatch list will be a tuple consisting
of the path, 'exists', 'size' or 'hash' according to what didn't match
(existence is checked first, then size, then hash), the expected
value and the actual value.
zinstalled-files.txtr TF)r r rI r r r' )r r r r rZ r! r! r" r s z)EggInfoDistribution.check_installed_filesc
C s dd }dd }t jj| jd}g }t jj|rtj|ddd|}xt|D ]l}|j }t jjt jj| j|}t jj|stj d | |j
d
rqHt jj |sH|j |||||f qHW W d Q R X |j |d d f |S )z
Iterates over the ``installed-files.txt`` entries and returns a tuple
``(path, hash, size)`` for each line.
:returns: a list of (path, hash, size)
c
S s0 t | d}z |j }W d |j X tj|j S )Nr )r r closer r Z hexdigest)r r Zcontentr! r! r" _md5 s
z6EggInfoDistribution.list_installed_files.._md5c S s t j| jS )N)r statst_size)r r! r! r" _size s z7EggInfoDistribution.list_installed_files.._sizezinstalled-files.txtrS zutf-8)r zNon-existent file: %s.pyc.pyoN)r r )
r r rI r r r r normpathrM r rF r r' )r r r r rb r r ri r! r! r" r s"
&z(EggInfoDistribution.list_installed_filesFc c s t jj| jd}d}tj|dddd}x\|D ]T}|j }|dkrFd}q,|s,t jjt jj| j|}|j| jr,|rz|V q,|V q,W W dQ R X dS ) a
Iterates over the ``installed-files.txt`` entries and returns paths for
each line if the path is pointing to a file located in the
``.egg-info`` directory or one of its subdirectories.
:parameter absolute: If *absolute* is ``True``, each returned path is
transformed into a local absolute path. Otherwise the
raw value from ``installed-files.txt`` is returned.
:type absolute: boolean
:returns: iterator of paths
zinstalled-files.txtTrS zutf-8)r z./FN)r r rI r r r r r )r Zabsoluter skipr r ri r! r! r" r s
z'EggInfoDistribution.list_distinfo_filesc C s t |to| j|jkS )N)rW r r )r r r! r! r" r s
zEggInfoDistribution.__eq__)N)F)r* r+ r, r- r r r# r r r r r r r r r r r! r! )r r" r N s K&
c @ s^ e Zd ZdZdd Zdd ZdddZd d
Zd d ZdddZ dddZ
dd Z dd Z dS )DependencyGrapha
Represents a dependency graph between distributions.
The dependency relationships are stored in an ``adjacency_list`` that maps
distributions to a list of ``(other, label)`` tuples where ``other``
is a distribution and the edge is labeled with ``label`` (i.e. the version
specifier, if such was provided). Also, for more efficient traversal, for
every distribution ``x``, a list of predecessors is kept in
``reverse_list[x]``. An edge from distribution ``a`` to
distribution ``b`` means that ``a`` depends on ``b``. If any missing
dependencies are found, they are stored in ``missing``, which is a
dictionary that maps distributions to a list of requirements that were not
provided by any other distributions.
c C s i | _ i | _i | _d S )N)adjacency_list reverse_listr )r r! r! r" r# . s zDependencyGraph.__init__c C s g | j |< g | j|< dS )zAdd the *distribution* to the graph.
:type distribution: :class:`distutils2.database.InstalledDistribution`
or :class:`distutils2.database.EggInfoDistribution`
N)r r )r distributionr! r! r" add_distribution3 s
z DependencyGraph.add_distributionNc C s6 | j | j||f || j| kr2| j| j| dS )a Add an edge from distribution *x* to distribution *y* with the given
*label*.
:type x: :class:`distutils2.database.InstalledDistribution` or
:class:`distutils2.database.EggInfoDistribution`
:type y: :class:`distutils2.database.InstalledDistribution` or
:class:`distutils2.database.EggInfoDistribution`
:type label: ``str`` or ``None``
N)r r' r )r xylabelr! r! r" add_edge= s
zDependencyGraph.add_edgec C s& t jd|| | jj|g j| dS )a
Add a missing *requirement* for the given *distribution*.
:type distribution: :class:`distutils2.database.InstalledDistribution`
or :class:`distutils2.database.EggInfoDistribution`
:type requirement: ``str``
z
%s missing %rN)rM rN r r% r' )r r r r! r! r" add_missingL s zDependencyGraph.add_missingc C s d|j |jf S )Nz%s %s)r r] )r r( r! r! r"
_repr_distW s zDependencyGraph._repr_distr c C s | j |g}xv| j| D ]h\}}| j |}|dk r>d||f }|jd| t| | j||d }|jd}|j|dd qW dj|S )zPrints only a subgraphNz%s [%s]z r r )r r r' r repr_noder extendrI )r r( leveloutputr r Z suboutputZsubsr! r! r" r Z s
zDependencyGraph.repr_nodeTc C s g }|j d x|| jj D ]n\}}t|dkr>| r>|j| xH|D ]@\}}|dk rn|j d|j|j|f qD|j d|j|jf qDW qW | rt|dkr|j d |j d |j d x&|D ] }|j d |j |j d
qW |j d |j d dS ) a9 Writes a DOT output for the graph to the provided file *f*.
If *skip_disconnected* is set to ``True``, then all distributions
that are not dependent on any other distribution are skipped.
:type f: has to support ``file``-like operations
:type skip_disconnected: ``bool``
zdigraph dependencies {
r Nz"%s" -> "%s" [label="%s"]
z
"%s" -> "%s"
zsubgraph disconnected {
zlabel = "Disconnected"
zbgcolor = red
z"%s"r z}
)r r itemsr r' r )r r Zskip_disconnectedZ disconnectedr( adjsr r r! r! r" to_dotg s&
zDependencyGraph.to_dotc s g }i }x&| j j D ]\}}|dd ||< qW xg x4t|j dd D ] \}}|sL j| ||= qLW srP x*|j D ] \}} fdd|D ||< q|W tjddd D |j q2W |t|j fS )aa
Perform a topological sort of the graph.
:return: A tuple, the first element of which is a topologically sorted
list of distributions, and the second element of which is a
list of distributions that cannot be sorted because they have
circular dependencies and so form a cycle.
Nc s g | ]\}}| kr||fqS r! r! )r rs rS ) to_remover! r" r s z4DependencyGraph.topological_sort..zMoving to result: %sc S s g | ]}d |j |jf qS )z%s (%s))r r] )r rs r! r! r" r s )r r listr' rM rN r keys)r rb Zalistkrt r! )r r" topological_sort s$
z DependencyGraph.topological_sortc C s6 g }x&| j j D ]\}}|j| j| qW dj|S )zRepresentation of the graphr )r r r' r rI )r r r( r r! r! r" r s zDependencyGraph.__repr__)N)r )T)
r* r+ r, r- r# r r
r r r r r r r! r! r! r" r s
r r. c C sf t |}t }i }xX| D ]P}|j| x@|jD ]6}t|\}}tjd||| |j|g j||f q.W qW x| D ]}|j |j
B |j B |j B }x|D ]} y|j
| }
W n6 tk
r tjd| | j d }|j
|}
Y nX |
j}d} ||krJxV|| D ]J\}} y|
j|}
W n tk
r, d}
Y nX |
r|j|| | d} P qW | s|j|| qW qrW |S )a6 Makes a dependency graph from the given distributions.
:parameter dists: a list of distributions
:type dists: list of :class:`distutils2.database.InstalledDistribution` and
:class:`distutils2.database.EggInfoDistribution` instances
:rtype: a :class:`DependencyGraph` instance
zAdd to provided: %s, %s, %sz+could not read version %r - using name onlyr FT)r r r rf r rM rN r% r' r r r r rd r r r r& rg r
r )distsr= graphrh r( ri r r] r r rd ZmatchedZproviderrg r! r! r"
make_graph sD
r c C s~ || krt d|j t| }|g}|j| }x@|rn|j }|j| x$|j| D ]}||krR|j| qRW q0W |jd |S )zRecursively generate a list of distributions from *dists* that are
dependent on *dist*.
:param dists: a list of distributions
:param dist: a distribution, member of *dists* for which we are interested
z1given distribution %r is not a member of the listr )r r r r popr' )r r( r Zdeptodors Zsuccr! r! r" get_dependent_dists s
r! c C sv || krt d|j t| }g }|j| }xD|rp|j d }|j| x$|j| D ]}||krT|j| qTW q.W |S )zRecursively generate a list of distributions from *dists* that are
required by *dist*.
:param dists: a list of distributions
:param dist: a distribution, member of *dists* for which we are interested
z1given distribution %r is not a member of the listr )r r r r r r' )r r( r r r rs Zpredr! r! r" get_required_dists s
r" c K s4 |j dd}tf |}| |_||_|p(d|_t|S )zO
A convenience method for making a dist given just a name and version.
summaryzPlaceholder for summary)r r r r] r# r )r r] kwargsr# r r! r! r" make_dist s
r% )r. )6r- Z
__future__r r r rJ r Zloggingr rH r/ r r: r r compatr r] r r r> r r
r utilr r
r r r r r __all__Z getLoggerr* rM r ZCOMMANDS_FILENAMEr rG r r r r r r r rO rP r r r! r" r% r! r! r! r" sV $
l 7 G M
6