File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/importlib_metadata.tar
Back
_adapters.py 0000644 00000003506 15030401031 0007047 0 ustar 00 import re import textwrap import email.message from ._text import FoldedCase class Message(email.message.Message): multiple_use_keys = set( map( FoldedCase, [ 'Classifier', 'Obsoletes-Dist', 'Platform', 'Project-URL', 'Provides-Dist', 'Provides-Extra', 'Requires-Dist', 'Requires-External', 'Supported-Platform', 'Dynamic', ], ) ) """ Keys that may be indicated multiple times per PEP 566. """ def __new__(cls, orig: email.message.Message): res = super().__new__(cls) vars(res).update(vars(orig)) return res def __init__(self, *args, **kwargs): self._headers = self._repair_headers() # suppress spurious error from mypy def __iter__(self): return super().__iter__() def _repair_headers(self): def redent(value): "Correct for RFC822 indentation" if not value or '\n' not in value: return value return textwrap.dedent(' ' * 8 + value) headers = [(key, redent(value)) for key, value in vars(self)['_headers']] if self._payload: headers.append(('Description', self.get_payload())) return headers @property def json(self): """ Convert PackageMetadata to a JSON-compatible format per PEP 0566. """ def transform(key): value = self.get_all(key) if key in self.multiple_use_keys else self[key] if key == 'Keywords': value = re.split(r'\s+', value) tk = key.lower().replace('-', '_') return tk, value return dict(map(transform, map(FoldedCase, self))) __pycache__/_meta.cpython-310.pyc 0000644 00000004405 15030401031 0012530 0 ustar 00 o L�a� � @ sX d dl mZ ddlmZmZmZmZmZmZ ed�Z G dd� de�Z G dd� de�Z d S ) � )�Protocol� )�Any�Dict�Iterator�List�TypeVar�Union�_Tc @ s� e Zd Zdefdd�Zdedefdd�Zdedefdd �Zde e fd d �Z dd ede de e e e f fdd�Zedeee ee e f f fdd��ZdS )�PackageMetadata�returnc C � d S �N� ��selfr r �:/usr/lib/python3/dist-packages/importlib_metadata/_meta.py�__len__ � zPackageMetadata.__len__�itemc C r r r )r r r r r � __contains__ r z PackageMetadata.__contains__�keyc C r r r )r r r r r � __getitem__ r zPackageMetadata.__getitem__c C r r r r r r r �__iter__ r zPackageMetadata.__iter__.�name�failobjc C � dS )zP Return all values associated with a possibly multi-valued key. Nr )r r r r r r �get_all � zPackageMetadata.get_allc C r )z9 A JSON-compatible form of the metadata. Nr r r r r �json r zPackageMetadata.jsonN).)�__name__� __module__� __qualname__�intr �str�boolr r r r r r r r r �propertyr r r r r r r s $(r c @ s< e Zd ZdZd dd�Zd dd�Zd dd�Zdefd d �Zd S ) � SimplePathzH A minimal subset of pathlib.Path required by PathDistribution. r c C r r r r r r r �joinpath& r zSimplePath.joinpathc C r r r r r r r � __truediv__) r zSimplePath.__truediv__c C r r r r r r r �parent, r zSimplePath.parentc C r r r r r r r � read_text/ r zSimplePath.read_textN)r r' ) r r! r" �__doc__r( r) r* r$ r+ r r r r r' ! s r' N) �_compatr �typingr r r r r r r r r' r r r r �<module> s __pycache__/_collections.cpython-310.pyc 0000644 00000002772 15030401031 0014125 0 ustar 00 o L�a� � @ s6 d dl Z G dd� de j�ZG dd� de �dd��ZdS )� Nc s( e Zd ZdZ� fdd�Zdd� Z� ZS )�FreezableDefaultDicta! Often it is desirable to prevent the mutation of a default dict after its initial construction, such as to prevent mutation during iteration. >>> dd = FreezableDefaultDict(list) >>> dd[0].append('1') >>> dd.freeze() >>> dd[1] [] >>> len(dd) 1 c s t | dt� j�|�S )N�_frozen)�getattr�super� __missing__)�self�key�� __class__� �A/usr/lib/python3/dist-packages/importlib_metadata/_collections.pyr s z FreezableDefaultDict.__missing__c s � fdd�� _ d S )Nc s � � � S )N)�default_factory)r �r r r �<lambda> s z-FreezableDefaultDict.freeze.<locals>.<lambda>)r r r r r �freeze s zFreezableDefaultDict.freeze)�__name__� __module__� __qualname__�__doc__r r � __classcell__r r r r r s r c @ s e Zd Zedd� �ZdS )�Pairc C s | t tj|�dd��� S )N�=� )�map�str�strip�split)�cls�textr r r �parse s z Pair.parseN)r r r � classmethodr r r r r r s r z name value)� collections� defaultdictr � namedtupler r r r r �<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000106214 15030401031 0013203 0 ustar 00 o L�a�r � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl Z d dl Z d dl Z d dl Z d dlZddlmZmZ ddlmZmZ ddlmZmZmZmZ ddlmZ ddl m Z ddlm Z m Z d d l m!Z! d d l"m#Z# d d l$m%Z% d d l m&Z& d d l'm(Z(m)Z)m*Z*m+Z+ g d�Z,G dd� de-�Z.G dd� d�Z/G dd� dee�0dd��Z1G dd� de2�Z3G dd� de3�Z4G dd � d �Z5G d d � d e5e6�Z7G d d � d ej8�Z9G d!d"� d"�Z:G d#d$� d$�Z;G d%d&� d&e%�Z<G d'd(� d(�Z=G d)d*� d*�Z>G d+d,� d,�Z?eG d-d.� d.ee<��Z@G d/d0� d0e;�ZAd1d2� ZBd3d4� ZCd5ej fd6d7�ZDd8d9� ZEd5e+e4e7f fd:d;�ZFd<d=� ZGd>d?� ZHd5e)eIe(eI f fd@dA�ZJdS )B� N� )� _adapters�_meta)�FreezableDefaultDict�Pair)� NullFinder� PyPy_repr�install� pypy_partial)� method_cache)�unique_everseen)�PackageMetadata� SimplePath)�suppress)� import_module)�MetaPathFinder)�starmap)�List�Mapping�Optional�Union) � Distribution�DistributionFinderr �PackageNotFoundError� distribution� distributions� entry_points�files�metadata�packages_distributions�requires�versionc @ s$ e Zd ZdZdd� Zedd� �ZdS )r zThe package was not found.c C s d| j � �S )Nz"No package metadata was found for ��name��self� r& �=/usr/lib/python3/dist-packages/importlib_metadata/__init__.py�__str__7 � z PackageNotFoundError.__str__c C s | j \}|S �N)�args�r% r# r& r& r' r# : s zPackageNotFoundError.nameN)�__name__� __module__� __qualname__�__doc__r( �propertyr# r& r& r& r' r 4 s r c @ sD e Zd ZdZe�d��� Zedd� �Z e d dd��Z e dd � �Z dS ) � Sectioneda� A simple entry point config parser for performance >>> for item in Sectioned.read(Sectioned._sample): ... print(item) Pair(name='sec1', value='# comments ignored') Pair(name='sec1', value='a = 1') Pair(name='sec1', value='b = 2') Pair(name='sec2', value='a = 2') >>> res = Sectioned.section_pairs(Sectioned._sample) >>> item = next(res) >>> item.name 'sec1' >>> item.value Pair(name='a', value='1') >>> item = next(res) >>> item.value Pair(name='b', value='2') >>> item = next(res) >>> item.name 'sec2' >>> item.value Pair(name='a', value='2') >>> list(res) [] zm [sec1] # comments ignored a = 1 b = 2 [sec2] a = 2 c C s dd� | j || jd�D �S )Nc s s. � | ]}|j d ur|jt�|j�d�V qd S )N)�value)r# �_replacer �parser3 )�.0�sectionr& r& r' � <genexpr>k s � ��z*Sectioned.section_pairs.<locals>.<genexpr>)�filter_)�read�valid��cls�textr& r& r' � section_pairsi s �zSectioned.section_pairsNc c sZ � t |ttj| �� ��}d }|D ]}|�d�o|�d�}|r$|�d�}qt||�V qd S )N�[�]z[])�filter�map�str�strip� splitlines� startswith�endswithr )r> r9 �linesr# r3 � section_matchr& r& r' r: q s � �zSectioned.readc C s | o| � d� S )N�#)rG )�liner& r& r' r; | � zSectioned.validr* ) r- r. r/ r0 �textwrap�dedent�lstrip�_sample� classmethodr? � staticmethodr: r; r& r& r& r' r2 @ s � � r2 c @ sz e Zd ZU dZe�d�Z dZed e d< dd� Z e dd � �Z e d d � �Z e d d � �Zdd� Zdd� Zdd� Zdd� ZdS )� EntryPointz�An entry point as defined by Python packaging conventions. See `the packaging docs on entry points <https://packaging.python.org/specifications/entry-points/>`_ for more information. zF(?P<module>[\w.]+)\s*(:\s*(?P<attr>[\w.]+))?\s*(?P<extras>\[.*\])?\s*$Nr �distc C sD | j �| j�}t|�d��}td|�d�pd�d��}t�t ||�S )z�Load the entry point from its definition. If only a module is indicated by the value, return that module. Otherwise, return the named object. �moduleN�attr� �.) �pattern�matchr3 r �grouprB �split� functools�reduce�getattr)r% r[ rV �attrsr& r& r' �load� s zEntryPoint.loadc C � | j �| j�}|�d�S )NrV �rZ r[ r3 r\ �r% r[ r& r& r' rV � � zEntryPoint.modulec C rc )NrW rd re r& r& r' rW � rf zEntryPoint.attrc C s( | j �| j�}tt�d|�d�pd��S )Nz\w+�extrasrX )rZ r[ r3 �list�re�finditerr\ re r& r& r' rg � s zEntryPoint.extrasc C s || _ | S r* �rU )r% rU r& r& r' �_for� s zEntryPoint._forc C s d}t �|t� t| j| f�S )zP Supply iter so one may construct dicts of EntryPoints by name. zJConstruction of dict of EntryPoints is deprecated in favor of EntryPoints.)�warnings�warn�DeprecationWarning�iterr# )r% �msgr& r& r' �__iter__� s � zEntryPoint.__iter__c C s | j | j| j| jffS r* )� __class__r# r3 r\ r$ r& r& r' � __reduce__� s �zEntryPoint.__reduce__c s( � fdd�|D �}t ttj|�� |��S )Nc 3 s � | ]}t � |�V qd S r* �r` )r6 �paramr$ r& r' r8 � � � z%EntryPoint.matches.<locals>.<genexpr>)�allrC �operator�eq�values)r% �paramsra r& r$ r' �matches� s zEntryPoint.matches)r- r. r/ r0 ri �compilerZ rU r �__annotations__rb r1 rV rW rg rl rr rt r} r& r& r& r' rT � s$ � rT �EntryPointBasezname value groupc s� e Zd ZdZejejdee d�d�Z � fdd�Z � fdd�Z � fd d �Z � fd d �Z� fd d�Z� fdd�Z� fdd�Z� fdd�Zdd� Z� fdd�Z� fdd�Zdd � Z� ZS ) �DeprecatedLista> Allow an otherwise immutable object to implement mutability for compatibility. >>> recwarn = getfixture('recwarn') >>> dl = DeprecatedList(range(3)) >>> dl[0] = 1 >>> dl.append(3) >>> del dl[3] >>> dl.reverse() >>> dl.sort() >>> dl.extend([4]) >>> dl.pop(-1) 4 >>> dl.remove(1) >>> dl += [5] >>> dl + [6] [1, 2, 5, 6] >>> dl + (6,) [1, 2, 5, 6] >>> dl.insert(0, 0) >>> dl [0, 1, 2, 5] >>> dl == [0, 1, 2, 5] True >>> dl == (0, 1, 2, 5) True >>> len(recwarn) 1 zAEntryPoints list interface is deprecated. Cast to list if needed.� �� stacklevelc � | � � t� j|i |��S r* )�_warn�super� __setitem__�r% r+ �kwargs�rs r& r' r� � � zDeprecatedList.__setitem__c r� r* )r� r� � __delitem__r� r� r& r' r� r� zDeprecatedList.__delitem__c r� r* )r� r� �appendr� r� r& r' r� r� zDeprecatedList.appendc r� r* )r� r� �reverser� r� r& r' r� r� zDeprecatedList.reversec r� r* )r� r� �extendr� r� r& r' r� r� zDeprecatedList.extendc r� r* )r� r� �popr� r� r& r' r� r� zDeprecatedList.popc r� r* )r� r� �remover� r� r& r' r� r� zDeprecatedList.removec r� r* )r� r� �__iadd__r� r� r& r' r� r� zDeprecatedList.__iadd__c C s, t |t�s | �� t|�}| �t| �| �S r* )� isinstance�tupler� rs �r% �otherr& r& r' �__add__ s zDeprecatedList.__add__c r� r* )r� r� �insertr� r� r& r' r� " r� zDeprecatedList.insertc r� r* )r� r� �sortr� r� r& r' r� & r� zDeprecatedList.sortc C s( t |t�s | �� t|�}t| ��|�S r* )r� r� r� �__eq__r� r& r& r' r� * s zDeprecatedList.__eq__)r- r. r/ r0 r^ �partialrm rn ro r r� r� r� r� r� r� r� r� r� r� r� r� r� � __classcell__r& r& r� r' r� � s( � r� c sh e Zd ZdZdZ� fdd�Zdd� Zedd� �Zed d � �Z e d d � �Z e d d� �Z e dd� �Z� ZS )� EntryPointszC An immutable collection of selectable EntryPoint objects. r& c sT t |t�rtjdtdd� t� �|�S z tt| j |d���W S t y) t |��w )z; Get the EntryPoint in self matching name. zGAccessing entry points by index is deprecated. Cast to tuple if needed.r� r� r" ) r� �intrm rn ro r� � __getitem__�nextrp �select� StopIteration�KeyErrorr, r� r& r' r� 9 s � �zEntryPoints.__getitem__c s t � fdd�| D ��S )zv Select entry points from self that match the given parameters (typically group and/or name). c 3 s$ � | ] }|j di � ��r|V qd S �Nr& )r} �r6 �ep�r| r& r' r8 O s �" z%EntryPoints.select.<locals>.<genexpr>�r� �r% r| r& r� r' r� J s zEntryPoints.selectc C � t dd� | D ��S )zB Return the set of all names of all entry points. c s � � | ]}|j V qd S r* r" r� r& r& r' r8 V � � z$EntryPoints.names.<locals>.<genexpr>��setr$ r& r& r' �namesQ s zEntryPoints.namesc C r� )z� Return the set of all groups of all entry points. For coverage while SelectableGroups is present. >>> EntryPoints().groups set() c s r� r* )r\ r� r& r& r' r8 a r� z%EntryPoints.groups.<locals>.<genexpr>r� r$ r& r& r' �groupsX � zEntryPoints.groupsc s | � fdd�| � |�D ��S )Nc 3 � � | ]}|� � �V qd S r* )rl r� rk r& r' r8 e rw z-EntryPoints._from_text_for.<locals>.<genexpr>)� _from_text)r= r> rU r& rk r' �_from_text_forc s zEntryPoints._from_text_forc C s t �t| �|pd��S �NrX )� itertoolsr rT � _parse_groupsr< r& r& r' r� g s zEntryPoints._from_textc C s dd� t �| �D �S )Nc s s$ � | ] }|j j|j j |jfV qd S r* �r3 r# )r6 �itemr& r& r' r8 m s � � �z,EntryPoints._parse_groups.<locals>.<genexpr>)r2 r? )r> r& r& r' r� k s �zEntryPoints._parse_groups)r- r. r/ r0 � __slots__r� r� r1 r� r� rR r� r� rS r� r� r& r& r� r' r� 2 s r� c sv e Zd ZdZejejdee d�d�Z � fdd�Z d� fdd � Z � fd d �Z � fd d �Z� fdd�Z� fdd�Z� ZS )� Deprecateda� Compatibility add-in for mapping to indicate that mapping behavior is deprecated. >>> recwarn = getfixture('recwarn') >>> class DeprecatedDict(Deprecated, dict): pass >>> dd = DeprecatedDict(foo='bar') >>> dd.get('baz', None) >>> dd['foo'] 'bar' >>> list(dd) ['foo'] >>> list(dd.keys()) ['foo'] >>> 'foo' in dd True >>> list(dd.values()) ['bar'] >>> len(recwarn) 1 z:SelectableGroups dict interface is deprecated. Use select.r� r� c s | � � t� �|�S r* )r� r� r� r, r� r& r' r� � � zDeprecated.__getitem__Nc s | � � t� �||�S r* )r� r� �get)r% r# �defaultr� r& r' r� � s zDeprecated.getc � | � � t� �� S r* )r� r� rr r$ r� r& r' rr � � zDeprecated.__iter__c s | � � t� j|� S r* )r� r� � __contains__)r% r+ r� r& r' r� � r� zDeprecated.__contains__c r� r* )r� r� �keysr$ r� r& r' r� � r� zDeprecated.keysc r� r* )r� r� r{ r$ r� r& r' r{ � r� zDeprecated.valuesr* )r- r. r/ r0 r^ r� rm rn ro r r� r� r� rr r� r� r{ r� r& r& r� r' r� s s � r� c sP e Zd ZdZedd� �Ze� fdd��Zedd� �Zedd � �Z d d � Z � Z S ) �SelectableGroupszs A backward- and forward-compatible result from entry_points that fully implements the dict interface. c C s4 t �d�}t||d�}t�||�}| dd� |D ��S )Nr\ ��keyc s s � | ] \}}|t |�fV qd S r* r� )r6 r\ �epsr& r& r' r8 � s � z(SelectableGroups.load.<locals>.<genexpr>)ry � attrgetter�sortedr� �groupby)r= r� �by_group�ordered�groupedr& r& r' rb � s zSelectableGroups.loadc s t t| ��� }ttj�|��S )zH Reconstruct a list of all entrypoints from the groups. )r� r� r{ r� r� �chain� from_iterable)r% r� r� r& r' �_all� s zSelectableGroups._allc C � | j jS r* )r� r� r$ r& r& r' r� � � zSelectableGroups.groupsc C r� )zR for coverage: >>> SelectableGroups().names set() )r� r� r$ r& r& r' r� � s zSelectableGroups.namesc K s |s| S | j jdi |��S r� )r� r� r� r& r& r' r� � s zSelectableGroups.select) r- r. r/ r0 rR rb r1 r� r� r� r� r� r& r& r� r' r� � s r� c @ s* e Zd ZdZd dd�Zdd� Zdd� Zd S ) � PackagePathz"A reference to a path in a package�utf-8c C s< | � � j|d�� }|�� W d � S 1 sw Y d S )N��encoding��locate�openr: )r% r� �streamr& r& r' � read_text� s $�zPackagePath.read_textc C s: | � � �d�� }|�� W d � S 1 sw Y d S )N�rbr� )r% r� r& r& r' � read_binary� s $�zPackagePath.read_binaryc C s | j �| �S )z'Return a path-like object for this path)rU � locate_filer$ r& r& r' r� � � zPackagePath.locateN)r� )r- r. r/ r0 r� r� r� r& r& r& r' r� � s r� c @ s e Zd Zdd� Zdd� ZdS )�FileHashc C s |� d�\| _}| _d S )N�=)� partition�moder3 )r% �spec�_r& r& r' �__init__� s zFileHash.__init__c C s d| j � d| j� d�S )Nz<FileHash mode: z value: �>)r� r3 r$ r& r& r' �__repr__� s zFileHash.__repr__N)r- r. r/ r� r� r& r& r& r' r� � s r� c @ s� e Zd ZdZejdd� �Zejdd� �Zedd� �Z edd � �Z e d d � �Z e d d � �Z ed-dd��Zedejfdd��Zedd� �Zedd� �Zedd� �Zedd� �Zed d � �Zd d � Zd d!� Zed"d#� �Zd$d%� Zd&d'� Z ed(d)� �Z e d*d+� �Z d,S ).r z A Python distribution package.c C � dS )z�Attempt to load metadata file given by the name. :param filename: The name of the file in the distribution info. :return: The text if found, otherwise None. Nr& �r% �filenamer& r& r' r� � � zDistribution.read_textc C r� )z[ Given a path to a file in this distribution, return a path to it. Nr& �r% �pathr& r& r' r� � r� zDistribution.locate_filec C sD | � � D ]}|tj|d��}tt|�d�}|dur | S qt|��)af Return the Distribution for the given package name. :param name: The name of the distribution package to search for. :return: The Distribution instance (or subclass thereof) for the named package, if found. :raises PackageNotFoundError: When the named package's distribution metadata cannot be found. r" N)�_discover_resolversr �Contextr� rp r )r= r# �resolver�distsrU r& r& r' � from_name� s �zDistribution.from_namec sN |� dd�� � r|rtd��� ptjdi |��� tj�� fdd�| �� D ��S )a Return an iterable of Distribution objects for all packages. Pass a ``context`` or pass keyword arguments for constructing a context. :context: A ``DistributionFinder.Context`` object. :return: Iterable of Distribution objects for all packages. �contextNz cannot accept context and kwargsc 3 s � | ]}|� �V qd S r* r& )r6 r� �r� r& r' r8 s � �z(Distribution.discover.<locals>.<genexpr>r& )r� � ValueErrorr r� r� r� r� r� )r= r� r& r� r' �discover s �zDistribution.discoverc C s t t�| ��S )z�Return a Distribution for the indicated metadata path :param path: a string or path-like object :return: a concrete Distribution instance for the path )�PathDistribution�pathlib�Path)r� r& r& r' �at s zDistribution.atc C s dd� t jD �} td| �S )z#Search the meta_path for resolvers.c s s � | ] }t |d d�V qdS )�find_distributionsNru )r6 �finderr& r& r' r8 , s � �z3Distribution._discover_resolvers.<locals>.<genexpr>N)�sys� meta_pathrB )�declaredr& r& r' r� ) s � z Distribution._discover_resolversrY c C s@ ddl m}m} |�|�}tj|j||d�}tt�|� |���S )Nr )�build�meta)� source_dir�system) �pep517r r � compat_systemr^ r� r� �zippr� � build_as_zip)r= �rootr r r �builderr& r& r' �_local1 s �zDistribution._local�returnc C s. | � d�p| � d�p| � d�}t�t�|��S )z�Return the parsed metadata for this Distribution. The returned object will have keys that name the various bits of metadata. See PEP 566 for details. �METADATAzPKG-INFOrX )r� r �Message�email�message_from_string�r% r> r& r& r' r = s ��zDistribution.metadatac C � | j d S )z8Return the 'Name' metadata for the distribution package.�Name�r r$ r& r& r' r# N � zDistribution.namec C s t �| j�S )z(Return a normalized version of the name.)�Prepared� normalizer# r$ r& r& r' �_normalized_nameS s z Distribution._normalized_namec C r )z;Return the 'Version' metadata for the distribution package.�Versionr r$ r& r& r' r! X r zDistribution.versionc C s t �| �d�| �S )Nzentry_points.txt)r� r� r� r$ r& r& r' r ] s zDistribution.entry_pointsc s6 � � � p� �� }d� fdd� }|ott|t�|���S )aB Files in this distribution. :return: List of PackagePath for this distribution or None Result is `None` if the metadata file that enumerates files (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is missing. Result may be empty if the metadata exists but is empty. Nc s6 t | �}|r t|�nd |_|rt|�nd |_� |_|S r* )r� r� �hashr� �sizerU )r# r �size_str�resultr$ r& r' � make_filen s z%Distribution.files.<locals>.make_file)NN)�_read_files_distinfo�_read_files_egginforh r �csv�reader)r% � file_linesr r& r$ r' r a s zDistribution.filesc C s | � d�}|o |�� S )z* Read the lines of RECORD �RECORD)r� rF r r& r& r' r w s z!Distribution._read_files_distinfoc C s | � d�}|otdj|�� �S )z` SOURCES.txt might contain literal commas, so wrap each line in quotes. z SOURCES.txtz"{}")r� rC �formatrF r r& r& r' r ~ s z Distribution._read_files_egginfoc C s | � � p| �� }|o t|�S )z6Generated requirements specified for this Distribution)�_read_dist_info_reqs�_read_egg_info_reqsrh )r% �reqsr& r& r' r � s zDistribution.requiresc C s | j �d�S )Nz Requires-Dist)r �get_allr$ r& r& r' r& � r) z!Distribution._read_dist_info_reqsc C s | � d�}|o | �|�S )Nz requires.txt)r� �_deps_from_requires_text)r% �sourcer& r& r' r' � s z Distribution._read_egg_info_reqsc C s | � t�|��S r* )�%_convert_egg_info_reqs_to_simple_reqsr2 r: )r= r+ r& r& r' r* � rM z%Distribution._deps_from_requires_textc # s6 � dd� � � fdd�}| D ] }|j ||j� V q dS )a� Historically, setuptools would solicit and store 'extra' requirements, including those with environment markers, in separate sections. More modern tools expect each dependency to be defined separately, with any relevant extras and environment markers attached directly to that requirement. This method converts the former to the latter. See _test_deps_from_requires_text for an example. c S s | od| � d�S )Nz extra == "�"r& r" r& r& r' �make_condition� s zJDistribution._convert_egg_info_reqs_to_simple_reqs.<locals>.make_conditionc sX | pd} | � d�\}}}|r|rd|� d�}ttd |� |�g��}|r*dd�|� S dS )NrX �:�(�)z; z and )r� rh rB �join)r7 �extra�sep�markers� conditions�r. r& r' �parse_condition� s zKDistribution._convert_egg_info_reqs_to_simple_reqs.<locals>.parse_conditionNr� )�sectionsr8 r7 r& r7 r' r, � s � �z2Distribution._convert_egg_info_reqs_to_simple_reqsN)rY ) r- r. r/ r0 �abc�abstractmethodr� r� rR r� r� rS r� r� r r1 r r r r# r r! r r r r r r& r' r* r, r& r& r& r' r � sL r c @ s2 e Zd ZdZG dd� d�Zeje� fdd��ZdS )r zJ A MetaPathFinder capable of discovering installed distributions. c @ s* e Zd ZdZdZ dd� Zedd� �ZdS )zDistributionFinder.Contextaw Keyword arguments presented by the caller to ``distributions()`` or ``Distribution.discover()`` to narrow the scope of a search for distributions in all DistributionFinders. Each DistributionFinder may expect any parameters and should attempt to honor the canonical parameters defined below when appropriate. Nc K s t | ��|� d S r* )�vars�update)r% r� r& r& r' r� � � z#DistributionFinder.Context.__init__c C s t | ��dtj�S )z� The sequence of directory path that a distribution finder should search. Typically refers to Python installed package paths such as "site-packages" directories and defaults to ``sys.path``. r� )r< r� r� r� r$ r& r& r' r� � r� z DistributionFinder.Context.path)r- r. r/ r0 r# r� r1 r� r& r& r& r' r� � s r� c C r� )z� Find distributions. Return an iterable of all Distribution instances capable of loading the metadata for packages matching the ``context``, a DistributionFinder.Context instance. Nr& )r% r� r& r& r' r� � r� z%DistributionFinder.find_distributionsN)r- r. r/ r0 r� r: r; r� r& r& r& r' r � s r c sh e Zd ZdZe�� � fdd��Zdd� Zdd� Zdd � Z d d � Z d d � Z e dd� �Z edd� �Z� ZS )�FastPathzF Micro-optimized class for searching a path for children. c s t � �| �S r* )r� �__new__)r= r r� r& r' r@ � r� zFastPath.__new__c C s t |�| _d S r* )rD r )r% r r& r& r' r� � � zFastPath.__init__c C s t �| j|�S r* )r� r� r )r% �childr& r& r' �joinpath� rA zFastPath.joinpathc C sl t t�� t�| jp d�W d � S 1 sw Y t t�� | �� W d � S 1 s/w Y g S r� )r � Exception�os�listdirr � zip_childrenr$ r& r& r' �children� s � �zFastPath.childrenc C s2 t �| j�}|j�� }|j| _t�dd� |D ��S )Nc s s" � | ] }|� tjd �d V qdS )r r N)r] � posixpathr4 )r6 rB r& r& r' r8 � s � z(FastPath.zip_children.<locals>.<genexpr>)r r� r �namelistrC �dict�fromkeys)r% �zip_pathr� r& r& r' rG � s zFastPath.zip_childrenc C s | � | j��|�S r* )�lookup�mtime�searchr, r& r& r' rP r> zFastPath.searchc C sD t t�� t�| j�jW d � S 1 sw Y | j�� d S r* )r �OSErrorrE �statr �st_mtimerN � cache_clearr$ r& r& r' rO s �zFastPath.mtimec C s t | �S r* )�Lookup)r% rO r& r& r' rN r� zFastPath.lookup)r- r. r/ r0 r^ � lru_cacher@ r� rC rH rG rP r1 rO r rN r� r& r& r� r' r? � s r? c @ s" e Zd Zdefdd�Zdd� ZdS )rU r� c C s� t j�|j��� }|�d�}tt�| _tt�| _ |� � D ]J}|�� }|�d�rD|� d�d � d�d }t �|�}| j| �|�|�� q |rf|dkrf|� d�d � d�d }t �|�}| j | �|�|�� q | j�� | j �� d S )Nz.egg�z .dist-infoz .egg-inforY r �-zegg-info)rE r� �basenamer �lowerrH r rh �infos�eggsrH � rpartitionr� r r r� rC �legacy_normalize�freeze) r% r� �base� base_is_eggrB �lowr# � normalized�legacy_normalizedr& r& r' r� s" � zLookup.__init__c C sP |r| j |j ntj�| j �� �}|r| j|j ntj�| j�� �}t�||�S r* )r[ rc r� r� r� r{ r\ rd )r% �preparedr[ r\ r& r& r' rP $ s ���� z Lookup.searchN)r- r. r/ r? r� rP r& r& r& r' rU s rU c @ s@ e Zd ZdZdZdZdd� Zedd� �Zedd� �Z d d � Z dS ) r zE A prepared search for metadata on a possibly-named package. Nc C s. || _ |d u r d S | �|�| _| �|�| _d S r* )r# r rc r^ rd r, r& r& r' r� : s zPrepared.__init__c C s t �dd| ��� �dd�S )zC PEP 503 normalization plus dashes as underscores. z[-_.]+rX r� )ri �subrZ �replacer" r& r& r' r A s zPrepared.normalizec C s | � � �dd�S )z| Normalize the package name as found in the convention in older packaging tools versions and specs. rX r� )rZ rg r" r& r& r' r^ H s zPrepared.legacy_normalizec C s t | j�S r* )�boolr# r$ r& r& r' �__bool__P s zPrepared.__bool__) r- r. r/ r0 rc rd r� rS r r^ ri r& r& r& r' r 2 s r c @ s4 e Zd ZdZe�� fdd�Zedd� �Zdd� Z dS ) �MetadataPathFinderz�A degenerate finder for distribution packages on the file system. This finder supplies only a find_distributions() method for versions of Python that do not have a PathFinder find_distributions(). c C s | � |j|j�}tt|�S )a Find distributions. Return an iterable of all Distribution instances capable of loading the metadata for packages matching ``context.name`` (or all names if ``None`` indicated) along the paths in the list of directories ``context.path``. )� _search_pathsr# r� rC r� )r% r� �foundr& r& r' r� \ s z%MetadataPathFinder.find_distributionsc s( t |�� tj�� fdd�tt|�D ��S )z1Find metadata directories in paths heuristically.c 3 r� r* )rP )r6 r� �re r& r' r8 l s � �z3MetadataPathFinder._search_paths.<locals>.<genexpr>)r r� r� r� rC r? )r= r# �pathsr& rm r' rk h s �z MetadataPathFinder._search_pathsc C s t j�� d S r* )r? r@ rT )r= r& r& r' �invalidate_cachesp rA z$MetadataPathFinder.invalidate_cachesN) r- r. r/ r0 r r� r� rR rk ro r& r& r& r' rj T s rj c sP e Zd Zdefdd�Zdd� Zejje_dd� Ze � fdd ��Z d d � Z � Z S ) r� r� c C s || _ dS )zfConstruct a distribution. :param path: SimplePath indicating the metadata directory. N)�_pathr� r& r& r' r� u s zPathDistribution.__init__c C sH t ttttt�� | j�|�jdd�W d � S 1 s w Y d S )Nr� r� ) r �FileNotFoundError�IsADirectoryErrorr� �NotADirectoryError�PermissionErrorrp rC r� r� r& r& r' r� | s �$�zPathDistribution.read_textc C s | j j| S r* )rp �parentr� r& r& r' r� � r) z PathDistribution.locate_filec s$ t j�t| j��}| �|�pt� jS )zz Performance optimization: where possible, resolve the normalized name from the file system path. )rE r� rY rD rp �_name_from_stemr� r )r% �stemr� r& r' r � s z!PathDistribution._normalized_namec C s0 t j�|�\}}|dvrd S |�d�\}}}|S )NrW rX )rE r� �splitextr� )r% rw r# �extr4 �restr& r& r' rv � s z PathDistribution._name_from_stem) r- r. r/ r r� r� r r0 r� r1 r rv r� r& r& r� r' r� t s r� c C s t �| �S )z�Get the ``Distribution`` instance for the named package. :param distribution_name: The name of the distribution package as a string. :return: A ``Distribution`` instance (or subclass thereof). )r r� ��distribution_namer& r& r' r � � r c K s t jdi | ��S )z|Get all ``Distribution`` instances in the current environment. :return: An iterable of ``Distribution`` instances. Nr& )r r� )r� r& r& r' r � s r r c C s t �| �jS )z�Get the metadata for the named package. :param distribution_name: The name of the distribution package to query. :return: A PackageMetadata containing the parsed metadata. )r r� r r{ r& r& r' r � s r c C � t | �jS )z�Get the version string for the named package. :param distribution_name: The name of the distribution package to query. :return: The version string for the package as defined in the package's "Version" metadata key. )r r! r{ r& r& r' r! � � r! c K sJ t �d�}tjt|d�}tj�dd� |t� �D ��}t � |�j di | ��S )a� Return EntryPoint objects for all installed packages. Pass selection parameters (group or name) to filter the result to entry points matching those properties (see EntryPoints.select()). For compatibility, returns ``SelectableGroups`` object unless selection parameters are supplied. In the future, this function will return ``EntryPoints`` instead of ``SelectableGroups`` even when no selection parameters are supplied. For maximum future compatibility, pass selection parameters or invoke ``.select`` with parameters on the result. :return: EntryPoints or SelectableGroups for all installed packages. r r� c s r� r* )r )r6 rU r& r& r' r8 � s � �z entry_points.<locals>.<genexpr>Nr& ) ry r� r^ r� r r� r� r� r r� rb r� )r| � norm_name�uniquer� r& r& r' r � s �r c C r~ )z�Return a list of files for the named package. :param distribution_name: The name of the distribution package to query. :return: List of files composing the distribution. )r r r{ r& r& r' r � r} r c C r~ )z� Return a list of requirements for the named package. :return: An iterator of requirements, suitable for packaging.requirement.Requirement. )r r r{ r& r& r' r � r r c C sJ t �t�} t� D ]}|�d�pd�� D ] }| | �|jd � qqt| �S )z� Return a mapping of top-level packages to their distributions. >>> import collections.abc >>> pkgs = packages_distributions() >>> all(isinstance(dist, collections.abc.Sequence) for dist in pkgs.values()) True z top_level.txtrX r ) � collections� defaultdictrh r r� r] r� r rK )� pkg_to_distrU �pkgr& r& r' r � s �r )KrE ri r: r! r� r r r� ry rN rm r^ r� rI r� rX r r � _collectionsr r �_compatr r r r � _functoolsr � _itertoolsr r r � contextlibr � importlibr � importlib.abcr r �typingr r r r �__all__�ModuleNotFoundErrorr r2 � namedtuplerT rh r� r� r� rK r� � PurePosixPathr� r� r r r? rU r rj r� r r r r! r r r rD r r& r& r& r' �<module> sn A �T]A7( I0,$" ( __pycache__/_compat.cpython-310.pyc 0000644 00000005271 15030401031 0013067 0 ustar 00 o L�a � @ s� d dl Z d dlZg d�Zzd dlmZ W n ey$ d dlmZ Y nw dd� Zdd� ZG dd � d �Z G d d � d �Z d d � Z dS )� N)�install� NullFinder� PyPy_repr�Protocol)r c C s t j�| � � t� | S )z� Class decorator for installation on sys.meta_path. Adds the backport DistributionFinder to sys.meta_path and attempts to disable the finder functionality of the stdlib DistributionFinder. )�sys� meta_path�append�disable_stdlib_finder)�cls� r �</usr/lib/python3/dist-packages/importlib_metadata/_compat.pyr s r c C s" dd� } t | tj�D ]}|`q dS )z� Give the backport primacy for discovering path-based distributions by monkey-patching the stdlib O_O. See #91 for more background for rationale on this sketchy behavior. c S s t | dd �dko t| d�S )N� __module__�_frozen_importlib_external�find_distributions)�getattr�hasattr)�finderr r r �matches) s ���z&disable_stdlib_finder.<locals>.matchesN)�filterr r r )r r r r r r s �r c @ s e Zd ZdZedd� �ZeZdS )r zj A "Finder" (aka "MetaClassFinder") that never finds any modules, but may find distributions. c O s d S )Nr )�args�kwargsr r r � find_spec8 s zNullFinder.find_specN)�__name__r � __qualname__�__doc__� staticmethodr � find_moduler r r r r 2 s r c @ s, e Zd ZdZeed�Zdd� ZereZ[dS )r zc Override repr for EntryPoint objects on PyPy to avoid __iter__ access. Ref #97, #102. �pypy_version_infoc s* � fdd�}d� t|� j��}d|� d�S )Nc s t � | �}| � d|��S )N�=)r )�name�value��selfr r � make_paramN s z-PyPy_repr.__compat_repr__.<locals>.make_paramz, z EntryPoint(�))�join�map�_fields)r" r# �paramsr r! r �__compat_repr__M s zPyPy_repr.__compat_repr__N) r r r r r r �affectedr) �__repr__r r r r r E s r c C s t �� dk}| | S )zY Adjust for variable stacklevel on partial under PyPy. Workaround for #327. �PyPy)�platform�python_implementation)�val�is_pypyr r r � pypy_partialZ s r1 ) r r- �__all__�typingr � ImportError�typing_extensionsr r r r r1 r r r r �<module> s � __pycache__/_itertools.cpython-310.pyc 0000644 00000001106 15030401031 0013621 0 ustar 00 o L�a_ � @ s d dl mZ ddd�ZdS )� )� filterfalseNc c sf � t � }|j}|du r t|j| �D ] }||� |V qdS | D ]}||�}||vr0||� |V q dS )zHList unique elements, preserving order. Remember all elements ever seen.N)�set�addr � __contains__)�iterable�key�seen�seen_add�element�k� r �?/usr/lib/python3/dist-packages/importlib_metadata/_itertools.py�unique_everseen s ����r )N)� itertoolsr r r r r r �<module> s __pycache__/_text.cpython-310.pyc 0000644 00000005777 15030401031 0012603 0 ustar 00 o L�a� � @ s( d dl Z ddlmZ G dd� de�ZdS )� N� )� method_cachec sr e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Z� fd d �Z dd� Z e � fdd��Z dd� Z ddd�Z� ZS )� FoldedCasea{ A case insensitive string class; behaves just like str except compares equal when the only variation is case. >>> s = FoldedCase('hello world') >>> s == 'Hello World' True >>> 'Hello World' == s True >>> s != 'Hello World' False >>> s.index('O') 4 >>> s.split('O') ['hell', ' w', 'rld'] >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta'])) ['alpha', 'Beta', 'GAMMA'] Sequence membership is straightforward. >>> "Hello World" in [s] True >>> s in ["Hello World"] True You may test for set inclusion, but candidate and elements must both be folded. >>> FoldedCase("Hello World") in {s} True >>> s in {FoldedCase("Hello World")} True String inclusion works as long as the FoldedCase object is on the right. >>> "hello" in FoldedCase("Hello World") True But not if the FoldedCase object is on the left: >>> FoldedCase('hello') in 'Hello World' False In that case, use in_: >>> FoldedCase('hello').in_('Hello World') True >>> FoldedCase('hello') > FoldedCase('Hello') False c C s | � � |� � k S �N��lower��self�other� r �:/usr/lib/python3/dist-packages/importlib_metadata/_text.py�__lt__C � zFoldedCase.__lt__c C s | � � |� � kS r r r r r r �__gt__F r zFoldedCase.__gt__c C s | � � |� � kS r r r r r r �__eq__I r zFoldedCase.__eq__c C s | � � |� � kS r r r r r r �__ne__L r zFoldedCase.__ne__c C s t | �� �S r )�hashr �r r r r �__hash__O s zFoldedCase.__hash__c s t t| ��� �|�� �S r )�superr r � __contains__r �� __class__r r r R s zFoldedCase.__contains__c C s | t |�v S )zDoes self appear in other?)r r r r r �in_U s zFoldedCase.in_c s t t| ��� S r )r r r r r r r r Z s zFoldedCase.lowerc C s | � � �|� � �S r )r �index)r �subr r r r ^ s zFoldedCase.index� r c C s t �t �|�t j�}|�| |�S r )�re�compile�escape�I�split)r �splitter�maxsplit�patternr r r r! a s zFoldedCase.split)r r )�__name__� __module__� __qualname__�__doc__r r r r r r r r r r r! � __classcell__r r r r r s ; r )r � _functoolsr �strr r r r r �<module> s __pycache__/_adapters.cpython-310.pyc 0000644 00000004463 15030401031 0013411 0 ustar 00 o L�aF � @ s< d dl Z d dlZd dlZddlmZ G dd� dejj�ZdS )� N� )� FoldedCasec sb e Zd Zeeeg d���Z dejj f� fdd� Z dd� Z � fdd�Z d d � Z ed d � �Z� ZS ) �Message) � ClassifierzObsoletes-Dist�Platformz Project-URLz Provides-DistzProvides-Extraz Requires-DistzRequires-ExternalzSupported-Platform�Dynamic�origc s" t � �| �}t|��t|�� |S �N)�super�__new__�vars�update)�clsr �res�� __class__� �>/usr/lib/python3/dist-packages/importlib_metadata/_adapters.pyr s zMessage.__new__c O s | � � | _d S r )�_repair_headers�_headers)�self�args�kwargsr r r �__init__# s zMessage.__init__c s t � �� S r )r �__iter__�r r r r r ' s zMessage.__iter__c s> dd� � � fdd�t | �d D �}| jr |�d| �� f� |S )Nc S s | rd| vr| S t �d| �S )z Correct for RFC822 indentation� z )�textwrap�dedent)�valuer r r �redent+ s z'Message._repair_headers.<locals>.redentc s g | ] \}}|� |�f�qS r r )�.0�keyr �r r r � <listcomp>1 s z+Message._repair_headers.<locals>.<listcomp>r � Description)r �_payload�append� get_payload)r �headersr r# r r * s zMessage._repair_headersc s � fdd�}t t|tt� ���S )z[ Convert PackageMetadata to a JSON-compatible format per PEP 0566. c sH | � j v r � �| �n� | }| dkrt�d|�}| �� �dd�}||fS )N�Keywordsz\s+�-�_)�multiple_use_keys�get_all�re�split�lower�replace)r" r �tkr r r � transform= s z Message.json.<locals>.transform)�dict�mapr )r r4 r r r �json6 s z Message.json)�__name__� __module__� __qualname__�setr6 r r- �email�messager r r r r �propertyr7 � __classcell__r r r r r s �� r )r/ r � email.messager< �_textr r= r r r r r �<module> s __pycache__/_functools.cpython-310.pyc 0000644 00000005131 15030401031 0013613 0 ustar 00 o L�a� � @ s d dl Z d dlZddd�ZdS )� Nc s( � pt �� � � �fdd�}dd� |_|S )aV Wrap lru_cache to support storing the cache data in the object instances. Abstracts the common paradigm where the method explicitly saves an underscore-prefixed protected property on first call and returns that subsequently. >>> class MyClass: ... calls = 0 ... ... @method_cache ... def method(self, value): ... self.calls += 1 ... return value >>> a = MyClass() >>> a.method(3) 3 >>> for x in range(75): ... res = a.method(x) >>> a.calls 75 Note that the apparent behavior will be exactly like that of lru_cache except that the cache is stored on each instance, so values in one instance will not flush values from another, and when an instance is deleted, so are the cached values for that instance. >>> b = MyClass() >>> for x in range(35): ... res = b.method(x) >>> b.calls 35 >>> a.method(0) 0 >>> a.calls 75 Note that if method had been decorated with ``functools.lru_cache()``, a.calls would have been 76 (due to the cached value of 0 having been flushed by the 'b' instance). Clear the cache with ``.cache_clear()`` >>> a.method.cache_clear() Same for a method that hasn't yet been called. >>> c = MyClass() >>> c.method.cache_clear() Another cache wrapper may be supplied: >>> cache = functools.lru_cache(maxsize=2) >>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache) >>> a = MyClass() >>> a.method2() 3 Caution - do not subsequently wrap the method with another decorator, such as ``@property``, which changes the semantics of the function. See also http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/ for another implementation and additional justification. c s0 t ��| �}� |�}t| �j|� ||i |��S �N)�types� MethodType�setattr�__name__)�self�args�kwargs� bound_method� cached_method�� cache_wrapper�method� �?/usr/lib/python3/dist-packages/importlib_metadata/_functools.py�wrapperK s z method_cache.<locals>.wrapperc S s d S r r r r r r �<lambda>S s z method_cache.<locals>.<lambda>)� functools� lru_cache� cache_clear)r r r r r r � method_cache s C r r )r r r r r r r �<module> s _meta.py 0000644 00000002202 15030401031 0006162 0 ustar 00 from ._compat import Protocol from typing import Any, Dict, Iterator, List, TypeVar, Union _T = TypeVar("_T") class PackageMetadata(Protocol): def __len__(self) -> int: ... # pragma: no cover def __contains__(self, item: str) -> bool: ... # pragma: no cover def __getitem__(self, key: str) -> str: ... # pragma: no cover def __iter__(self) -> Iterator[str]: ... # pragma: no cover def get_all(self, name: str, failobj: _T = ...) -> Union[List[Any], _T]: """ Return all values associated with a possibly multi-valued key. """ @property def json(self) -> Dict[str, Union[str, List[str]]]: """ A JSON-compatible form of the metadata. """ class SimplePath(Protocol): """ A minimal subset of pathlib.Path required by PathDistribution. """ def joinpath(self) -> 'SimplePath': ... # pragma: no cover def __truediv__(self) -> 'SimplePath': ... # pragma: no cover def parent(self) -> 'SimplePath': ... # pragma: no cover def read_text(self) -> str: ... # pragma: no cover py.typed 0000644 00000000000 15030401031 0006214 0 ustar 00 _compat.py 0000644 00000005013 15030401031 0006522 0 ustar 00 import sys import platform __all__ = ['install', 'NullFinder', 'PyPy_repr', 'Protocol'] try: from typing import Protocol except ImportError: # pragma: no cover """ pytest-mypy complains here because: error: Incompatible import of "Protocol" (imported name has type "typing_extensions._SpecialForm", local name has type "typing._SpecialForm") """ from typing_extensions import Protocol # type: ignore def install(cls): """ Class decorator for installation on sys.meta_path. Adds the backport DistributionFinder to sys.meta_path and attempts to disable the finder functionality of the stdlib DistributionFinder. """ sys.meta_path.append(cls()) disable_stdlib_finder() return cls def disable_stdlib_finder(): """ Give the backport primacy for discovering path-based distributions by monkey-patching the stdlib O_O. See #91 for more background for rationale on this sketchy behavior. """ def matches(finder): return getattr( finder, '__module__', None ) == '_frozen_importlib_external' and hasattr(finder, 'find_distributions') for finder in filter(matches, sys.meta_path): # pragma: nocover del finder.find_distributions class NullFinder: """ A "Finder" (aka "MetaClassFinder") that never finds any modules, but may find distributions. """ @staticmethod def find_spec(*args, **kwargs): return None # In Python 2, the import system requires finders # to have a find_module() method, but this usage # is deprecated in Python 3 in favor of find_spec(). # For the purposes of this finder (i.e. being present # on sys.meta_path but having no other import # system functionality), the two methods are identical. find_module = find_spec class PyPy_repr: """ Override repr for EntryPoint objects on PyPy to avoid __iter__ access. Ref #97, #102. """ affected = hasattr(sys, 'pypy_version_info') def __compat_repr__(self): # pragma: nocover def make_param(name): value = getattr(self, name) return f'{name}={value!r}' params = ', '.join(map(make_param, self._fields)) return f'EntryPoint({params})' if affected: # pragma: nocover __repr__ = __compat_repr__ del affected def pypy_partial(val): """ Adjust for variable stacklevel on partial under PyPy. Workaround for #327. """ is_pypy = platform.python_implementation() == 'PyPy' return val + is_pypy _text.py 0000644 00000004226 15030401031 0006230 0 ustar 00 import re from ._functools import method_cache # from jaraco.text 3.5 class FoldedCase(str): """ A case insensitive string class; behaves just like str except compares equal when the only variation is case. >>> s = FoldedCase('hello world') >>> s == 'Hello World' True >>> 'Hello World' == s True >>> s != 'Hello World' False >>> s.index('O') 4 >>> s.split('O') ['hell', ' w', 'rld'] >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta'])) ['alpha', 'Beta', 'GAMMA'] Sequence membership is straightforward. >>> "Hello World" in [s] True >>> s in ["Hello World"] True You may test for set inclusion, but candidate and elements must both be folded. >>> FoldedCase("Hello World") in {s} True >>> s in {FoldedCase("Hello World")} True String inclusion works as long as the FoldedCase object is on the right. >>> "hello" in FoldedCase("Hello World") True But not if the FoldedCase object is on the left: >>> FoldedCase('hello') in 'Hello World' False In that case, use in_: >>> FoldedCase('hello').in_('Hello World') True >>> FoldedCase('hello') > FoldedCase('Hello') False """ def __lt__(self, other): return self.lower() < other.lower() def __gt__(self, other): return self.lower() > other.lower() def __eq__(self, other): return self.lower() == other.lower() def __ne__(self, other): return self.lower() != other.lower() def __hash__(self): return hash(self.lower()) def __contains__(self, other): return super(FoldedCase, self).lower().__contains__(other.lower()) def in_(self, other): "Does self appear in other?" return self in FoldedCase(other) # cache lower since it's likely to be called frequently. @method_cache def lower(self): return super(FoldedCase, self).lower() def index(self, sub): return self.lower().index(sub.lower()) def split(self, splitter=' ', maxsplit=0): pattern = re.compile(re.escape(splitter), re.I) return pattern.split(self, maxsplit) _collections.py 0000644 00000001347 15030401031 0007563 0 ustar 00 import collections # from jaraco.collections 3.3 class FreezableDefaultDict(collections.defaultdict): """ Often it is desirable to prevent the mutation of a default dict after its initial construction, such as to prevent mutation during iteration. >>> dd = FreezableDefaultDict(list) >>> dd[0].append('1') >>> dd.freeze() >>> dd[1] [] >>> len(dd) 1 """ def __missing__(self, key): return getattr(self, '_frozen', super().__missing__)(key) def freeze(self): self._frozen = lambda key: self.default_factory() class Pair(collections.namedtuple('Pair', 'name value')): @classmethod def parse(cls, text): return cls(*map(str.strip, text.split("=", 1))) _functools.py 0000644 00000004705 15030401031 0007262 0 ustar 00 import types import functools # from jaraco.functools 3.3 def method_cache(method, cache_wrapper=None): """ Wrap lru_cache to support storing the cache data in the object instances. Abstracts the common paradigm where the method explicitly saves an underscore-prefixed protected property on first call and returns that subsequently. >>> class MyClass: ... calls = 0 ... ... @method_cache ... def method(self, value): ... self.calls += 1 ... return value >>> a = MyClass() >>> a.method(3) 3 >>> for x in range(75): ... res = a.method(x) >>> a.calls 75 Note that the apparent behavior will be exactly like that of lru_cache except that the cache is stored on each instance, so values in one instance will not flush values from another, and when an instance is deleted, so are the cached values for that instance. >>> b = MyClass() >>> for x in range(35): ... res = b.method(x) >>> b.calls 35 >>> a.method(0) 0 >>> a.calls 75 Note that if method had been decorated with ``functools.lru_cache()``, a.calls would have been 76 (due to the cached value of 0 having been flushed by the 'b' instance). Clear the cache with ``.cache_clear()`` >>> a.method.cache_clear() Same for a method that hasn't yet been called. >>> c = MyClass() >>> c.method.cache_clear() Another cache wrapper may be supplied: >>> cache = functools.lru_cache(maxsize=2) >>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache) >>> a = MyClass() >>> a.method2() 3 Caution - do not subsequently wrap the method with another decorator, such as ``@property``, which changes the semantics of the function. See also http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/ for another implementation and additional justification. """ cache_wrapper = cache_wrapper or functools.lru_cache() def wrapper(self, *args, **kwargs): # it's the first call, replace the method with a cached, bound method bound_method = types.MethodType(method, self) cached_method = cache_wrapper(bound_method) setattr(self, method.__name__, cached_method) return cached_method(*args, **kwargs) # Support cache clear even before cache has been created. wrapper.cache_clear = lambda: None return wrapper _itertools.py 0000644 00000001137 15030401031 0007266 0 ustar 00 from itertools import filterfalse def unique_everseen(iterable, key=None): "List unique elements, preserving order. Remember all elements ever seen." # unique_everseen('AAAABBBCCDAABBB') --> A B C D # unique_everseen('ABBCcAD', str.lower) --> A B C D seen = set() seen_add = seen.add if key is None: for element in filterfalse(seen.__contains__, iterable): seen_add(element) yield element else: for element in iterable: k = key(element) if k not in seen: seen_add(k) yield element __init__.py 0000644 00000071315 15030401031 0006647 0 ustar 00 import os import re import abc import csv import sys import zipp import email import pathlib import operator import textwrap import warnings import functools import itertools import posixpath import collections from . import _adapters, _meta from ._collections import FreezableDefaultDict, Pair from ._compat import ( NullFinder, PyPy_repr, install, pypy_partial, ) from ._functools import method_cache from ._itertools import unique_everseen from ._meta import PackageMetadata, SimplePath from contextlib import suppress from importlib import import_module from importlib.abc import MetaPathFinder from itertools import starmap from typing import List, Mapping, Optional, Union __all__ = [ 'Distribution', 'DistributionFinder', 'PackageMetadata', 'PackageNotFoundError', 'distribution', 'distributions', 'entry_points', 'files', 'metadata', 'packages_distributions', 'requires', 'version', ] class PackageNotFoundError(ModuleNotFoundError): """The package was not found.""" def __str__(self): return f"No package metadata was found for {self.name}" @property def name(self): (name,) = self.args return name class Sectioned: """ A simple entry point config parser for performance >>> for item in Sectioned.read(Sectioned._sample): ... print(item) Pair(name='sec1', value='# comments ignored') Pair(name='sec1', value='a = 1') Pair(name='sec1', value='b = 2') Pair(name='sec2', value='a = 2') >>> res = Sectioned.section_pairs(Sectioned._sample) >>> item = next(res) >>> item.name 'sec1' >>> item.value Pair(name='a', value='1') >>> item = next(res) >>> item.value Pair(name='b', value='2') >>> item = next(res) >>> item.name 'sec2' >>> item.value Pair(name='a', value='2') >>> list(res) [] """ _sample = textwrap.dedent( """ [sec1] # comments ignored a = 1 b = 2 [sec2] a = 2 """ ).lstrip() @classmethod def section_pairs(cls, text): return ( section._replace(value=Pair.parse(section.value)) for section in cls.read(text, filter_=cls.valid) if section.name is not None ) @staticmethod def read(text, filter_=None): lines = filter(filter_, map(str.strip, text.splitlines())) name = None for value in lines: section_match = value.startswith('[') and value.endswith(']') if section_match: name = value.strip('[]') continue yield Pair(name, value) @staticmethod def valid(line): return line and not line.startswith('#') class EntryPoint( PyPy_repr, collections.namedtuple('EntryPointBase', 'name value group') ): """An entry point as defined by Python packaging conventions. See `the packaging docs on entry points <https://packaging.python.org/specifications/entry-points/>`_ for more information. """ pattern = re.compile( r'(?P<module>[\w.]+)\s*' r'(:\s*(?P<attr>[\w.]+))?\s*' r'(?P<extras>\[.*\])?\s*$' ) """ A regular expression describing the syntax for an entry point, which might look like: - module - package.module - package.module:attribute - package.module:object.attribute - package.module:attr [extra1, extra2] Other combinations are possible as well. The expression is lenient about whitespace around the ':', following the attr, and following any extras. """ dist: Optional['Distribution'] = None def load(self): """Load the entry point from its definition. If only a module is indicated by the value, return that module. Otherwise, return the named object. """ match = self.pattern.match(self.value) module = import_module(match.group('module')) attrs = filter(None, (match.group('attr') or '').split('.')) return functools.reduce(getattr, attrs, module) @property def module(self): match = self.pattern.match(self.value) return match.group('module') @property def attr(self): match = self.pattern.match(self.value) return match.group('attr') @property def extras(self): match = self.pattern.match(self.value) return list(re.finditer(r'\w+', match.group('extras') or '')) def _for(self, dist): self.dist = dist return self def __iter__(self): """ Supply iter so one may construct dicts of EntryPoints by name. """ msg = ( "Construction of dict of EntryPoints is deprecated in " "favor of EntryPoints." ) warnings.warn(msg, DeprecationWarning) return iter((self.name, self)) def __reduce__(self): return ( self.__class__, (self.name, self.value, self.group), ) def matches(self, **params): attrs = (getattr(self, param) for param in params) return all(map(operator.eq, params.values(), attrs)) class DeprecatedList(list): """ Allow an otherwise immutable object to implement mutability for compatibility. >>> recwarn = getfixture('recwarn') >>> dl = DeprecatedList(range(3)) >>> dl[0] = 1 >>> dl.append(3) >>> del dl[3] >>> dl.reverse() >>> dl.sort() >>> dl.extend([4]) >>> dl.pop(-1) 4 >>> dl.remove(1) >>> dl += [5] >>> dl + [6] [1, 2, 5, 6] >>> dl + (6,) [1, 2, 5, 6] >>> dl.insert(0, 0) >>> dl [0, 1, 2, 5] >>> dl == [0, 1, 2, 5] True >>> dl == (0, 1, 2, 5) True >>> len(recwarn) 1 """ _warn = functools.partial( warnings.warn, "EntryPoints list interface is deprecated. Cast to list if needed.", DeprecationWarning, stacklevel=pypy_partial(2), ) def __setitem__(self, *args, **kwargs): self._warn() return super().__setitem__(*args, **kwargs) def __delitem__(self, *args, **kwargs): self._warn() return super().__delitem__(*args, **kwargs) def append(self, *args, **kwargs): self._warn() return super().append(*args, **kwargs) def reverse(self, *args, **kwargs): self._warn() return super().reverse(*args, **kwargs) def extend(self, *args, **kwargs): self._warn() return super().extend(*args, **kwargs) def pop(self, *args, **kwargs): self._warn() return super().pop(*args, **kwargs) def remove(self, *args, **kwargs): self._warn() return super().remove(*args, **kwargs) def __iadd__(self, *args, **kwargs): self._warn() return super().__iadd__(*args, **kwargs) def __add__(self, other): if not isinstance(other, tuple): self._warn() other = tuple(other) return self.__class__(tuple(self) + other) def insert(self, *args, **kwargs): self._warn() return super().insert(*args, **kwargs) def sort(self, *args, **kwargs): self._warn() return super().sort(*args, **kwargs) def __eq__(self, other): if not isinstance(other, tuple): self._warn() other = tuple(other) return tuple(self).__eq__(other) class EntryPoints(DeprecatedList): """ An immutable collection of selectable EntryPoint objects. """ __slots__ = () def __getitem__(self, name): # -> EntryPoint: """ Get the EntryPoint in self matching name. """ if isinstance(name, int): warnings.warn( "Accessing entry points by index is deprecated. " "Cast to tuple if needed.", DeprecationWarning, stacklevel=2, ) return super().__getitem__(name) try: return next(iter(self.select(name=name))) except StopIteration: raise KeyError(name) def select(self, **params): """ Select entry points from self that match the given parameters (typically group and/or name). """ return EntryPoints(ep for ep in self if ep.matches(**params)) @property def names(self): """ Return the set of all names of all entry points. """ return set(ep.name for ep in self) @property def groups(self): """ Return the set of all groups of all entry points. For coverage while SelectableGroups is present. >>> EntryPoints().groups set() """ return set(ep.group for ep in self) @classmethod def _from_text_for(cls, text, dist): return cls(ep._for(dist) for ep in cls._from_text(text)) @classmethod def _from_text(cls, text): return itertools.starmap(EntryPoint, cls._parse_groups(text or '')) @staticmethod def _parse_groups(text): return ( (item.value.name, item.value.value, item.name) for item in Sectioned.section_pairs(text) ) class Deprecated: """ Compatibility add-in for mapping to indicate that mapping behavior is deprecated. >>> recwarn = getfixture('recwarn') >>> class DeprecatedDict(Deprecated, dict): pass >>> dd = DeprecatedDict(foo='bar') >>> dd.get('baz', None) >>> dd['foo'] 'bar' >>> list(dd) ['foo'] >>> list(dd.keys()) ['foo'] >>> 'foo' in dd True >>> list(dd.values()) ['bar'] >>> len(recwarn) 1 """ _warn = functools.partial( warnings.warn, "SelectableGroups dict interface is deprecated. Use select.", DeprecationWarning, stacklevel=pypy_partial(2), ) def __getitem__(self, name): self._warn() return super().__getitem__(name) def get(self, name, default=None): self._warn() return super().get(name, default) def __iter__(self): self._warn() return super().__iter__() def __contains__(self, *args): self._warn() return super().__contains__(*args) def keys(self): self._warn() return super().keys() def values(self): self._warn() return super().values() class SelectableGroups(Deprecated, dict): """ A backward- and forward-compatible result from entry_points that fully implements the dict interface. """ @classmethod def load(cls, eps): by_group = operator.attrgetter('group') ordered = sorted(eps, key=by_group) grouped = itertools.groupby(ordered, by_group) return cls((group, EntryPoints(eps)) for group, eps in grouped) @property def _all(self): """ Reconstruct a list of all entrypoints from the groups. """ groups = super(Deprecated, self).values() return EntryPoints(itertools.chain.from_iterable(groups)) @property def groups(self): return self._all.groups @property def names(self): """ for coverage: >>> SelectableGroups().names set() """ return self._all.names def select(self, **params): if not params: return self return self._all.select(**params) class PackagePath(pathlib.PurePosixPath): """A reference to a path in a package""" def read_text(self, encoding='utf-8'): with self.locate().open(encoding=encoding) as stream: return stream.read() def read_binary(self): with self.locate().open('rb') as stream: return stream.read() def locate(self): """Return a path-like object for this path""" return self.dist.locate_file(self) class FileHash: def __init__(self, spec): self.mode, _, self.value = spec.partition('=') def __repr__(self): return f'<FileHash mode: {self.mode} value: {self.value}>' class Distribution: """A Python distribution package.""" @abc.abstractmethod def read_text(self, filename): """Attempt to load metadata file given by the name. :param filename: The name of the file in the distribution info. :return: The text if found, otherwise None. """ @abc.abstractmethod def locate_file(self, path): """ Given a path to a file in this distribution, return a path to it. """ @classmethod def from_name(cls, name): """Return the Distribution for the given package name. :param name: The name of the distribution package to search for. :return: The Distribution instance (or subclass thereof) for the named package, if found. :raises PackageNotFoundError: When the named package's distribution metadata cannot be found. """ for resolver in cls._discover_resolvers(): dists = resolver(DistributionFinder.Context(name=name)) dist = next(iter(dists), None) if dist is not None: return dist else: raise PackageNotFoundError(name) @classmethod def discover(cls, **kwargs): """Return an iterable of Distribution objects for all packages. Pass a ``context`` or pass keyword arguments for constructing a context. :context: A ``DistributionFinder.Context`` object. :return: Iterable of Distribution objects for all packages. """ context = kwargs.pop('context', None) if context and kwargs: raise ValueError("cannot accept context and kwargs") context = context or DistributionFinder.Context(**kwargs) return itertools.chain.from_iterable( resolver(context) for resolver in cls._discover_resolvers() ) @staticmethod def at(path): """Return a Distribution for the indicated metadata path :param path: a string or path-like object :return: a concrete Distribution instance for the path """ return PathDistribution(pathlib.Path(path)) @staticmethod def _discover_resolvers(): """Search the meta_path for resolvers.""" declared = ( getattr(finder, 'find_distributions', None) for finder in sys.meta_path ) return filter(None, declared) @classmethod def _local(cls, root='.'): from pep517 import build, meta system = build.compat_system(root) builder = functools.partial( meta.build, source_dir=root, system=system, ) return PathDistribution(zipp.Path(meta.build_as_zip(builder))) @property def metadata(self) -> _meta.PackageMetadata: """Return the parsed metadata for this Distribution. The returned object will have keys that name the various bits of metadata. See PEP 566 for details. """ text = ( self.read_text('METADATA') or self.read_text('PKG-INFO') # This last clause is here to support old egg-info files. Its # effect is to just end up using the PathDistribution's self._path # (which points to the egg-info file) attribute unchanged. or self.read_text('') ) return _adapters.Message(email.message_from_string(text)) @property def name(self): """Return the 'Name' metadata for the distribution package.""" return self.metadata['Name'] @property def _normalized_name(self): """Return a normalized version of the name.""" return Prepared.normalize(self.name) @property def version(self): """Return the 'Version' metadata for the distribution package.""" return self.metadata['Version'] @property def entry_points(self): return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self) @property def files(self): """Files in this distribution. :return: List of PackagePath for this distribution or None Result is `None` if the metadata file that enumerates files (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is missing. Result may be empty if the metadata exists but is empty. """ file_lines = self._read_files_distinfo() or self._read_files_egginfo() def make_file(name, hash=None, size_str=None): result = PackagePath(name) result.hash = FileHash(hash) if hash else None result.size = int(size_str) if size_str else None result.dist = self return result return file_lines and list(starmap(make_file, csv.reader(file_lines))) def _read_files_distinfo(self): """ Read the lines of RECORD """ text = self.read_text('RECORD') return text and text.splitlines() def _read_files_egginfo(self): """ SOURCES.txt might contain literal commas, so wrap each line in quotes. """ text = self.read_text('SOURCES.txt') return text and map('"{}"'.format, text.splitlines()) @property def requires(self): """Generated requirements specified for this Distribution""" reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs() return reqs and list(reqs) def _read_dist_info_reqs(self): return self.metadata.get_all('Requires-Dist') def _read_egg_info_reqs(self): source = self.read_text('requires.txt') return source and self._deps_from_requires_text(source) @classmethod def _deps_from_requires_text(cls, source): return cls._convert_egg_info_reqs_to_simple_reqs(Sectioned.read(source)) @staticmethod def _convert_egg_info_reqs_to_simple_reqs(sections): """ Historically, setuptools would solicit and store 'extra' requirements, including those with environment markers, in separate sections. More modern tools expect each dependency to be defined separately, with any relevant extras and environment markers attached directly to that requirement. This method converts the former to the latter. See _test_deps_from_requires_text for an example. """ def make_condition(name): return name and f'extra == "{name}"' def parse_condition(section): section = section or '' extra, sep, markers = section.partition(':') if extra and markers: markers = f'({markers})' conditions = list(filter(None, [markers, make_condition(extra)])) return '; ' + ' and '.join(conditions) if conditions else '' for section in sections: yield section.value + parse_condition(section.name) class DistributionFinder(MetaPathFinder): """ A MetaPathFinder capable of discovering installed distributions. """ class Context: """ Keyword arguments presented by the caller to ``distributions()`` or ``Distribution.discover()`` to narrow the scope of a search for distributions in all DistributionFinders. Each DistributionFinder may expect any parameters and should attempt to honor the canonical parameters defined below when appropriate. """ name = None """ Specific name for which a distribution finder should match. A name of ``None`` matches all distributions. """ def __init__(self, **kwargs): vars(self).update(kwargs) @property def path(self): """ The sequence of directory path that a distribution finder should search. Typically refers to Python installed package paths such as "site-packages" directories and defaults to ``sys.path``. """ return vars(self).get('path', sys.path) @abc.abstractmethod def find_distributions(self, context=Context()): """ Find distributions. Return an iterable of all Distribution instances capable of loading the metadata for packages matching the ``context``, a DistributionFinder.Context instance. """ class FastPath: """ Micro-optimized class for searching a path for children. """ @functools.lru_cache() # type: ignore def __new__(cls, root): return super().__new__(cls) def __init__(self, root): self.root = str(root) def joinpath(self, child): return pathlib.Path(self.root, child) def children(self): with suppress(Exception): return os.listdir(self.root or '') with suppress(Exception): return self.zip_children() return [] def zip_children(self): zip_path = zipp.Path(self.root) names = zip_path.root.namelist() self.joinpath = zip_path.joinpath return dict.fromkeys(child.split(posixpath.sep, 1)[0] for child in names) def search(self, name): return self.lookup(self.mtime).search(name) @property def mtime(self): with suppress(OSError): return os.stat(self.root).st_mtime self.lookup.cache_clear() @method_cache def lookup(self, mtime): return Lookup(self) class Lookup: def __init__(self, path: FastPath): base = os.path.basename(path.root).lower() base_is_egg = base.endswith(".egg") self.infos = FreezableDefaultDict(list) self.eggs = FreezableDefaultDict(list) for child in path.children(): low = child.lower() if low.endswith((".dist-info", ".egg-info")): # rpartition is faster than splitext and suitable for this purpose. name = low.rpartition(".")[0].partition("-")[0] normalized = Prepared.normalize(name) self.infos[normalized].append(path.joinpath(child)) elif base_is_egg and low == "egg-info": name = base.rpartition(".")[0].partition("-")[0] legacy_normalized = Prepared.legacy_normalize(name) self.eggs[legacy_normalized].append(path.joinpath(child)) self.infos.freeze() self.eggs.freeze() def search(self, prepared): infos = ( self.infos[prepared.normalized] if prepared else itertools.chain.from_iterable(self.infos.values()) ) eggs = ( self.eggs[prepared.legacy_normalized] if prepared else itertools.chain.from_iterable(self.eggs.values()) ) return itertools.chain(infos, eggs) class Prepared: """ A prepared search for metadata on a possibly-named package. """ normalized = None legacy_normalized = None def __init__(self, name): self.name = name if name is None: return self.normalized = self.normalize(name) self.legacy_normalized = self.legacy_normalize(name) @staticmethod def normalize(name): """ PEP 503 normalization plus dashes as underscores. """ return re.sub(r"[-_.]+", "-", name).lower().replace('-', '_') @staticmethod def legacy_normalize(name): """ Normalize the package name as found in the convention in older packaging tools versions and specs. """ return name.lower().replace('-', '_') def __bool__(self): return bool(self.name) @install class MetadataPathFinder(NullFinder, DistributionFinder): """A degenerate finder for distribution packages on the file system. This finder supplies only a find_distributions() method for versions of Python that do not have a PathFinder find_distributions(). """ def find_distributions(self, context=DistributionFinder.Context()): """ Find distributions. Return an iterable of all Distribution instances capable of loading the metadata for packages matching ``context.name`` (or all names if ``None`` indicated) along the paths in the list of directories ``context.path``. """ found = self._search_paths(context.name, context.path) return map(PathDistribution, found) @classmethod def _search_paths(cls, name, paths): """Find metadata directories in paths heuristically.""" prepared = Prepared(name) return itertools.chain.from_iterable( path.search(prepared) for path in map(FastPath, paths) ) def invalidate_caches(cls): FastPath.__new__.cache_clear() class PathDistribution(Distribution): def __init__(self, path: SimplePath): """Construct a distribution. :param path: SimplePath indicating the metadata directory. """ self._path = path def read_text(self, filename): with suppress( FileNotFoundError, IsADirectoryError, KeyError, NotADirectoryError, PermissionError, ): return self._path.joinpath(filename).read_text(encoding='utf-8') read_text.__doc__ = Distribution.read_text.__doc__ def locate_file(self, path): return self._path.parent / path @property def _normalized_name(self): """ Performance optimization: where possible, resolve the normalized name from the file system path. """ stem = os.path.basename(str(self._path)) return self._name_from_stem(stem) or super()._normalized_name def _name_from_stem(self, stem): name, ext = os.path.splitext(stem) if ext not in ('.dist-info', '.egg-info'): return name, sep, rest = stem.partition('-') return name def distribution(distribution_name): """Get the ``Distribution`` instance for the named package. :param distribution_name: The name of the distribution package as a string. :return: A ``Distribution`` instance (or subclass thereof). """ return Distribution.from_name(distribution_name) def distributions(**kwargs): """Get all ``Distribution`` instances in the current environment. :return: An iterable of ``Distribution`` instances. """ return Distribution.discover(**kwargs) def metadata(distribution_name) -> _meta.PackageMetadata: """Get the metadata for the named package. :param distribution_name: The name of the distribution package to query. :return: A PackageMetadata containing the parsed metadata. """ return Distribution.from_name(distribution_name).metadata def version(distribution_name): """Get the version string for the named package. :param distribution_name: The name of the distribution package to query. :return: The version string for the package as defined in the package's "Version" metadata key. """ return distribution(distribution_name).version def entry_points(**params) -> Union[EntryPoints, SelectableGroups]: """Return EntryPoint objects for all installed packages. Pass selection parameters (group or name) to filter the result to entry points matching those properties (see EntryPoints.select()). For compatibility, returns ``SelectableGroups`` object unless selection parameters are supplied. In the future, this function will return ``EntryPoints`` instead of ``SelectableGroups`` even when no selection parameters are supplied. For maximum future compatibility, pass selection parameters or invoke ``.select`` with parameters on the result. :return: EntryPoints or SelectableGroups for all installed packages. """ norm_name = operator.attrgetter('_normalized_name') unique = functools.partial(unique_everseen, key=norm_name) eps = itertools.chain.from_iterable( dist.entry_points for dist in unique(distributions()) ) return SelectableGroups.load(eps).select(**params) def files(distribution_name): """Return a list of files for the named package. :param distribution_name: The name of the distribution package to query. :return: List of files composing the distribution. """ return distribution(distribution_name).files def requires(distribution_name): """ Return a list of requirements for the named package. :return: An iterator of requirements, suitable for packaging.requirement.Requirement. """ return distribution(distribution_name).requires def packages_distributions() -> Mapping[str, List[str]]: """ Return a mapping of top-level packages to their distributions. >>> import collections.abc >>> pkgs = packages_distributions() >>> all(isinstance(dist, collections.abc.Sequence) for dist in pkgs.values()) True """ pkg_to_dist = collections.defaultdict(list) for dist in distributions(): for pkg in (dist.read_text('top_level.txt') or '').split(): pkg_to_dist[pkg].append(dist.metadata['Name']) return dict(pkg_to_dist)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings