File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/packaging.tar
Back
__pycache__/tags.cpython-310.pyc 0000644 00000027572 15030043575 0012432 0 ustar 00 o �7]hS= � @ s U d dl Z d dlZd dlZd dlZd dlmZ d dlmZmZm Z m Z m Z m Z m Z mZmZmZ ddlmZmZ e �e�Ze e Zeeef Zdddd d d �Zeeef e d < ej d kZ G dd� d�Z dedee fdd�Z dHdede!deeedf fdd�Z"dedefdd�Z#d ede!fd d �Z$dHd ede!de e fd d!�Z% dIdd"�d e e d#e e e d$e e e de!de e f d%d&�Z&de e fd'd(�Z' dIdd"�d)e e d#e e e d$e e e de!de e f d*d+�Z(d ede e fd,d-�Z) dId e e d)e e d$e e e de e fd.d/�Z*e fd0ed1e!defd2d3�Z+d4ed5ede e fd6d7�Z, dJd4e e d0e e de e fd8d9�Z-e fd1e!de e fd:d;�Z.de e fd<d=�Z/de e fd>d?�Z0defd@dA�Z1dd"�de!defdBdC�Z2d4edefdDdE�Z3dd"�de!de e fdFdG�Z4dS )K� N)�EXTENSION_SUFFIXES) �Dict� FrozenSet�Iterable�Iterator�List�Optional�Sequence�Tuple�Union�cast� )� _manylinux� _musllinux�py�cp�pp�ip�jy)�python�cpython�pypy� ironpython�jython�INTERPRETER_SHORT_NAMESl c @ s� e Zd ZdZg d�Zdedededdfdd �Zedefd d ��Zedefd d ��Z edefdd��Z de de fdd�Z defdd�Zdefdd�Zdefdd�ZdS )�Tagz� A representation of the tag triple for a wheel. Instances are considered immutable and thus are hashable. Equality checking is also supported. )� _interpreter�_abi� _platform�_hash� interpreter�abi�platform�returnNc C s8 |� � | _|� � | _|� � | _t| j| j| jf�| _d S �N)�lowerr r r �hashr )�selfr r! r" � r( �</usr/lib/python3/dist-packages/pip/_vendor/packaging/tags.py�__init__4 s z Tag.__init__c C � | j S r$ )r �r' r( r( r) r ? � zTag.interpreterc C r+ r$ )r r, r( r( r) r! C r- zTag.abic C r+ r$ )r r, r( r( r) r" G r- z Tag.platform�otherc C s> t |t�stS | j|jko | j|jko | j|jko | j|jkS r$ )� isinstancer �NotImplementedr r r r )r' r. r( r( r) �__eq__K s � � �z Tag.__eq__c C r+ r$ )r r, r( r( r) �__hash__V s z Tag.__hash__c C s | j � d| j� d| j� �S )N�-)r r r r, r( r( r) �__str__Y s z Tag.__str__c C s d| � dt | �� d�S )N�<z @ �>)�idr, r( r( r) �__repr__\ s z Tag.__repr__)�__name__� __module__� __qualname__�__doc__� __slots__�strr* �propertyr r! r" �object�boolr1 �intr2 r4 r8 r( r( r( r) r * s r �tagr# c C s` t � }| �d�\}}}|�d�D ]}|�d�D ]}|�d�D ] }|�t|||�� q qqt|�S )z� Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. Returning a set is required due to the possibility that the tag is a compressed tag set. r3 �.)�set�split�addr � frozenset)rC �tags� interpreters�abis� platformsr r! � platform_r( r( r) � parse_tag` s ��rN F�name�warnc C s& t �| �}|d u r|rt�d| � |S )Nz>Config variable '%s' is unset, Python ABI tag may be incorrect)� sysconfig�get_config_var�logger�debug)rO rP �valuer( r( r) �_get_config_varp s �rV �stringc C s | � dd�� dd�S )NrD �_r3 )�replace)rW r( r( r) �_normalize_stringy s rZ �python_versionc C s t | �dko t| �dkS )zj Determine if the Python version supports abi3. PEP 384 was first implemented in Python 3.2. r )� � )�len�tuple)r[ r( r( r) � _abi3_applies} s r` � py_versionc C s� t | �} g }t| d d� �}d } }}td|�}ttd�}dtv } |s,|d u r.|s,| r.d}| dk rXtd|�} | s=| d u r?d }| d k rWtd |�} | d ksU| d u rWtjd krWd}n |rb|�d|� �� |�ddj ||||d�� |S )Nr] � �Py_DEBUG�gettotalrefcountz_d.pyd�d)r\ � � WITH_PYMALLOC�m)r\ r\ �Py_UNICODE_SIZE� i�� �ur r z"cp{version}{debug}{pymalloc}{ucs4})�versionrT �pymalloc�ucs4) r_ �_version_nodotrV �hasattr�sysr � maxunicode�append�insert�format) ra rP rK rl rT rm rn � with_debug� has_refcount�has_ext� with_pymalloc� unicode_sizer( r( r) � _cpython_abis� s8 ���r{ �rP rK rL c # sB � | s t jdd� } dt| dd� �� �� |du r't| �dkr%t| |�}ng }t|�}dD ]}z|�|� W q- ty? Y q-w t|pEt� �}|D ]}|D ] }t � ||�V qMqIt | �rh� fdd�|D �E dH � fdd�|D �E dH t | �r�t | d d dd �D ] }|D ]}d j t| d |f�d �� t � d |�V q�q�dS dS )a Yields the tags for a CPython interpreter. The tags consist of: - cp<python_version>-<abi>-<platform> - cp<python_version>-abi3-<platform> - cp<python_version>-none-<platform> - cp<less than python_version>-abi3-<platform> # Older Python versions down to 3.2. If python_version only specifies a major version then user-provided ABIs and the 'none' ABItag will be used. If 'abi3' or 'none' are specified in 'abis' then they will be yielded at their normal position and not at the beginning. Nr] r r )�abi3�nonec 3 � � | ] }t � d |�V qdS )r} N�r ��.0rM �r r( r) � <genexpr>� � � z cpython_tags.<locals>.<genexpr>c 3 r )r~ Nr� r� r� r( r) r� � r� ���z cp{version}r �rl r} ) rq � version_inforo r^ r{ �list�remove� ValueError� platform_tagsr r` �rangeru )r[ rK rL rP � explicit_abir! rM � minor_versionr( r� r) � cpython_tags� sB � �����r� c c s" � t �d�} | rt| �V d S d S )N�SOABI)rQ rR rZ )r! r( r( r) � _generic_abi� s � �r� r c c s� � | st � }t|d�}d�||g�} |du rt� }t|p t� �}t|�}d|vr-|�d� |D ]}|D ] }t| ||�V q3q/dS )z� Yields the tags for a generic interpreter. The tags consist of: - <interpreter>-<abi>-<platform> The "none" ABI will be added if it was not explicitly provided. r| rb Nr~ )�interpreter_name�interpreter_version�joinr� r� r� rs r )r rK rL rP � interp_name�interp_versionr! rM r( r( r) � generic_tags� s � ��r� c c s| � t | �dkrdt| dd� �� �V d| d � �V t | �dkr:t| d d dd�D ]}dt| d |f�� �V q+dS dS )z� Yields Python versions in descending order. After the latest version, the major-only version will be yielded, and then all previous versions of that major version. r r Nr] r r� )r^ ro r� )ra �minorr( r( r) �_py_interpreter_range s � �r� c c sz � | s t jdd� } t|pt� �}t| �D ]}|D ] }t|d|�V qq|r-t|dd�V t| �D ] }t|dd�V q1dS )z� Yields the sequence of tags that are compatible with a specific version of Python. The tags consist of: - py*-none-<platform> - <interpreter>-none-any # ... if `interpreter` is provided. - py*-none-any Nr] r~ �any)rq r� r� r� r� r )r[ r rL rl rM r( r( r) �compatible_tags s � � �r� �arch�is_32bitc C s |s| S | � d�r dS dS )N�ppc�i386)� startswith)r� r� r( r( r) � _mac_arch/ s r� rl �cpu_archc C s� |g}|dkr| dk r g S |� g d�� n7|dkr'| dk r g S |� g d�� n%|dkr;| dks3| dk r5g S |�d� n|d krL| d krEg S |� d d g� |d v rU|�d� |dv r^|�d� |S )N�x86_64)� rj )�intel�fat64�fat32r� )r� r� �fat�ppc64)r� � r� r� )r� � r� r� > �arm64r� � universal2> r� r� r� r� r� � universal)�extendrs )rl r� �formatsr( r( r) �_mac_binary_formats9 s, r� c c s� � t �� \}}}| du r tdttt|�d�dd� ���} n| } |du r)t|�}n|}d| krU| dk rUt| d dd�D ]}d |f}t ||�}|D ] }d j d ||d �V qHq;| dkr{t| d d d�D ]} | d f}t ||�}|D ] }d j | d |d �V qnqa| dkr�|d kr�tddd�D ] }d |f}t ||�}|D ]}d j |d |d |d �V q�q�dS tddd�D ]}d |f}d}d j |d |d |d �V q�dS dS )aD Yields the platform tags for a macOS system. The `version` parameter is a two-item tuple specifying the macOS version to generate platform tags for. The `arch` parameter is the CPU architecture to generate platform tags for. Both parameters default to the appropriate value for the current system. N� MacVersionrD r] )r� r )� r r r� r� z&macosx_{major}_{minor}_{binary_format})�majorr� � binary_formatr r� � r\ r� ) r" �mac_verr r_ �maprB rF r� r� r� ru ) rl r� � version_strrX r� r� �compat_version�binary_formatsr� � major_versionr( r( r) � mac_platformsY sb � $ �� �� ��� ��r� c c sh � t t�� �}| r|dkrd}n|dkrd}|�dd�\}}t�||�E d H t�|�E d H |V d S )N� linux_x86_64� linux_i686� linux_aarch64� linux_armv7lrX r )rZ rQ � get_platformrF r r� r )r� �linuxrX r� r( r( r) �_linux_platforms� s � r� c c s � t t�� �V d S r$ )rZ rQ r� r( r( r( r) �_generic_platforms� s �r� c C s* t �� dkr t� S t �� dkrt� S t� S )z; Provides the platform tags for this installation. �Darwin�Linux)r" �systemr� r� r� r( r( r( r) r� � s r� c C s t jj} t�| �p | S )z6 Returns the name of the running interpreter. )rq �implementationrO r �get)rO r( r( r) r� � s r� c C s2 t d| d�}|rt|�}|S ttjdd� �}|S )z9 Returns the version of the running interpreter. �py_version_nodotr| Nr] )rV r> ro rq r� )rP rl r( r( r) r� � s �r� c C s d� tt| ��S )Nrb )r� r� r> r� r( r( r) ro � s ro c c sZ � t � }|dkrt| d�E dH nt� E dH |dkr%tdd�E dH dS t� E dH dS )z� Returns the sequence of tag triples for the running interpreter. The order of the sequence corresponds to priority order for the interpreter, from most to least important. r r| Nr �pp3r� )r� r� r� r� )rP r� r( r( r) �sys_tags� s � r� )F)NNN)NN)5�loggingr" rq rQ �importlib.machineryr �typingr r r r r r r r r r rb r r � getLoggerr9 rS rB � PythonVersionr� r r> �__annotations__�maxsize�_32_BIT_INTERPRETERr rN rA rV rZ r` r{ r� r� r� r� r� r� r� r� r� r� r� r� r� ro r� r( r( r( r) �<module> s� 0 � 6" %��� � �� �9��� � �� � ��� � � !��� �H __pycache__/__init__.cpython-310.pyc 0000644 00000000632 15030043575 0013217 0 ustar 00 o �7]h� � @ s4 d dl mZmZmZmZmZmZmZmZ g d�Z dS )� )� __author__� __copyright__� __email__� __license__� __summary__� __title__�__uri__� __version__)r r r r r r r r N) � __about__r r r r r r r r �__all__� r r �@/usr/lib/python3/dist-packages/pip/_vendor/packaging/__init__.py�<module> s ( __pycache__/_typing.cpython-310.pyc 0000644 00000002674 15030043575 0013141 0 ustar 00 o c�a � @ s2 d Z ddgZ dZerddlmZ dS dd� ZdS ) a; For neatly implementing static typing in packaging. `mypy` - the static type analysis tool we use - uses the `typing` module, which provides core functionality fundamental to mypy's functioning. Generally, `typing` would be imported at runtime and used in that fashion - it acts as a no-op at runtime and does not have any run-time overhead by design. As it turns out, `typing` is not vendorable - it uses separate sources for Python 2/Python 3. Thus, this codebase can not expect it to be present. To work around this, mypy allows the typing import to be behind a False-y optional to prevent it from running at runtime and type-comments can be used to remove the need for the types to be accessible directly during runtime. This module provides the False-y guard in a nicely named fashion so that a curious maintainer can reach here to read this. In packaging, all static-typing related imports should be guarded as follows: from packaging._typing import TYPE_CHECKING if TYPE_CHECKING: from typing import ... Ref: https://github.com/python/mypy/issues/3216 � TYPE_CHECKING�castF� )r )r c C s |S )N� )�type_�valuer r �B/usr/lib/python3/dist-packages/wheel/vendored/packaging/_typing.pyr / s N)�__doc__�__all__�typingr r r r r r �<module> s _typing.py 0000644 00000003424 15030043575 0006574 0 ustar 00 """For neatly implementing static typing in packaging. `mypy` - the static type analysis tool we use - uses the `typing` module, which provides core functionality fundamental to mypy's functioning. Generally, `typing` would be imported at runtime and used in that fashion - it acts as a no-op at runtime and does not have any run-time overhead by design. As it turns out, `typing` is not vendorable - it uses separate sources for Python 2/Python 3. Thus, this codebase can not expect it to be present. To work around this, mypy allows the typing import to be behind a False-y optional to prevent it from running at runtime and type-comments can be used to remove the need for the types to be accessible directly during runtime. This module provides the False-y guard in a nicely named fashion so that a curious maintainer can reach here to read this. In packaging, all static-typing related imports should be guarded as follows: from packaging._typing import TYPE_CHECKING if TYPE_CHECKING: from typing import ... Ref: https://github.com/python/mypy/issues/3216 """ __all__ = ["TYPE_CHECKING", "cast"] # The TYPE_CHECKING constant defined by the typing module is False at runtime # but True while type checking. if False: # pragma: no cover from typing import TYPE_CHECKING else: TYPE_CHECKING = False # typing's cast syntax requires calling typing.cast at runtime, but we don't # want to import typing at runtime. Here, we inform the type checkers that # we're importing `typing.cast` as `cast` and re-implement typing.cast's # runtime behavior in a block that is ignored by type checkers. if TYPE_CHECKING: # pragma: no cover # not executed at runtime from typing import cast else: # executed at runtime def cast(type_, value): # noqa return value tags.py 0000644 00000036523 15030043575 0006067 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import logging import platform import sys import sysconfig from importlib.machinery import EXTENSION_SUFFIXES from typing import ( Dict, FrozenSet, Iterable, Iterator, List, Optional, Sequence, Tuple, Union, cast, ) from . import _manylinux, _musllinux logger = logging.getLogger(__name__) PythonVersion = Sequence[int] MacVersion = Tuple[int, int] INTERPRETER_SHORT_NAMES: Dict[str, str] = { "python": "py", # Generic. "cpython": "cp", "pypy": "pp", "ironpython": "ip", "jython": "jy", } _32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32 class Tag: """ A representation of the tag triple for a wheel. Instances are considered immutable and thus are hashable. Equality checking is also supported. """ __slots__ = ["_interpreter", "_abi", "_platform", "_hash"] def __init__(self, interpreter: str, abi: str, platform: str) -> None: self._interpreter = interpreter.lower() self._abi = abi.lower() self._platform = platform.lower() # The __hash__ of every single element in a Set[Tag] will be evaluated each time # that a set calls its `.disjoint()` method, which may be called hundreds of # times when scanning a page of links for packages with tags matching that # Set[Tag]. Pre-computing the value here produces significant speedups for # downstream consumers. self._hash = hash((self._interpreter, self._abi, self._platform)) @property def interpreter(self) -> str: return self._interpreter @property def abi(self) -> str: return self._abi @property def platform(self) -> str: return self._platform def __eq__(self, other: object) -> bool: if not isinstance(other, Tag): return NotImplemented return ( (self._hash == other._hash) # Short-circuit ASAP for perf reasons. and (self._platform == other._platform) and (self._abi == other._abi) and (self._interpreter == other._interpreter) ) def __hash__(self) -> int: return self._hash def __str__(self) -> str: return f"{self._interpreter}-{self._abi}-{self._platform}" def __repr__(self) -> str: return f"<{self} @ {id(self)}>" def parse_tag(tag: str) -> FrozenSet[Tag]: """ Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. Returning a set is required due to the possibility that the tag is a compressed tag set. """ tags = set() interpreters, abis, platforms = tag.split("-") for interpreter in interpreters.split("."): for abi in abis.split("."): for platform_ in platforms.split("."): tags.add(Tag(interpreter, abi, platform_)) return frozenset(tags) def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]: value = sysconfig.get_config_var(name) if value is None and warn: logger.debug( "Config variable '%s' is unset, Python ABI tag may be incorrect", name ) return value def _normalize_string(string: str) -> str: return string.replace(".", "_").replace("-", "_") def _abi3_applies(python_version: PythonVersion) -> bool: """ Determine if the Python version supports abi3. PEP 384 was first implemented in Python 3.2. """ return len(python_version) > 1 and tuple(python_version) >= (3, 2) def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]: py_version = tuple(py_version) # To allow for version comparison. abis = [] version = _version_nodot(py_version[:2]) debug = pymalloc = ucs4 = "" with_debug = _get_config_var("Py_DEBUG", warn) has_refcount = hasattr(sys, "gettotalrefcount") # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled # extension modules is the best option. # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 has_ext = "_d.pyd" in EXTENSION_SUFFIXES if with_debug or (with_debug is None and (has_refcount or has_ext)): debug = "d" if py_version < (3, 8): with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) if with_pymalloc or with_pymalloc is None: pymalloc = "m" if py_version < (3, 3): unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) if unicode_size == 4 or ( unicode_size is None and sys.maxunicode == 0x10FFFF ): ucs4 = "u" elif debug: # Debug builds can also load "normal" extension modules. # We can also assume no UCS-4 or pymalloc requirement. abis.append(f"cp{version}") abis.insert( 0, "cp{version}{debug}{pymalloc}{ucs4}".format( version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4 ), ) return abis def cpython_tags( python_version: Optional[PythonVersion] = None, abis: Optional[Iterable[str]] = None, platforms: Optional[Iterable[str]] = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a CPython interpreter. The tags consist of: - cp<python_version>-<abi>-<platform> - cp<python_version>-abi3-<platform> - cp<python_version>-none-<platform> - cp<less than python_version>-abi3-<platform> # Older Python versions down to 3.2. If python_version only specifies a major version then user-provided ABIs and the 'none' ABItag will be used. If 'abi3' or 'none' are specified in 'abis' then they will be yielded at their normal position and not at the beginning. """ if not python_version: python_version = sys.version_info[:2] interpreter = f"cp{_version_nodot(python_version[:2])}" if abis is None: if len(python_version) > 1: abis = _cpython_abis(python_version, warn) else: abis = [] abis = list(abis) # 'abi3' and 'none' are explicitly handled later. for explicit_abi in ("abi3", "none"): try: abis.remove(explicit_abi) except ValueError: pass platforms = list(platforms or platform_tags()) for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) if _abi3_applies(python_version): yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) if _abi3_applies(python_version): for minor_version in range(python_version[1] - 1, 1, -1): for platform_ in platforms: interpreter = "cp{version}".format( version=_version_nodot((python_version[0], minor_version)) ) yield Tag(interpreter, "abi3", platform_) def _generic_abi() -> Iterator[str]: abi = sysconfig.get_config_var("SOABI") if abi: yield _normalize_string(abi) def generic_tags( interpreter: Optional[str] = None, abis: Optional[Iterable[str]] = None, platforms: Optional[Iterable[str]] = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a generic interpreter. The tags consist of: - <interpreter>-<abi>-<platform> The "none" ABI will be added if it was not explicitly provided. """ if not interpreter: interp_name = interpreter_name() interp_version = interpreter_version(warn=warn) interpreter = "".join([interp_name, interp_version]) if abis is None: abis = _generic_abi() platforms = list(platforms or platform_tags()) abis = list(abis) if "none" not in abis: abis.append("none") for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: """ Yields Python versions in descending order. After the latest version, the major-only version will be yielded, and then all previous versions of that major version. """ if len(py_version) > 1: yield f"py{_version_nodot(py_version[:2])}" yield f"py{py_version[0]}" if len(py_version) > 1: for minor in range(py_version[1] - 1, -1, -1): yield f"py{_version_nodot((py_version[0], minor))}" def compatible_tags( python_version: Optional[PythonVersion] = None, interpreter: Optional[str] = None, platforms: Optional[Iterable[str]] = None, ) -> Iterator[Tag]: """ Yields the sequence of tags that are compatible with a specific version of Python. The tags consist of: - py*-none-<platform> - <interpreter>-none-any # ... if `interpreter` is provided. - py*-none-any """ if not python_version: python_version = sys.version_info[:2] platforms = list(platforms or platform_tags()) for version in _py_interpreter_range(python_version): for platform_ in platforms: yield Tag(version, "none", platform_) if interpreter: yield Tag(interpreter, "none", "any") for version in _py_interpreter_range(python_version): yield Tag(version, "none", "any") def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: if not is_32bit: return arch if arch.startswith("ppc"): return "ppc" return "i386" def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]: formats = [cpu_arch] if cpu_arch == "x86_64": if version < (10, 4): return [] formats.extend(["intel", "fat64", "fat32"]) elif cpu_arch == "i386": if version < (10, 4): return [] formats.extend(["intel", "fat32", "fat"]) elif cpu_arch == "ppc64": # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? if version > (10, 5) or version < (10, 4): return [] formats.append("fat64") elif cpu_arch == "ppc": if version > (10, 6): return [] formats.extend(["fat32", "fat"]) if cpu_arch in {"arm64", "x86_64"}: formats.append("universal2") if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: formats.append("universal") return formats def mac_platforms( version: Optional[MacVersion] = None, arch: Optional[str] = None ) -> Iterator[str]: """ Yields the platform tags for a macOS system. The `version` parameter is a two-item tuple specifying the macOS version to generate platform tags for. The `arch` parameter is the CPU architecture to generate platform tags for. Both parameters default to the appropriate value for the current system. """ version_str, _, cpu_arch = platform.mac_ver() if version is None: version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2]))) else: version = version if arch is None: arch = _mac_arch(cpu_arch) else: arch = arch if (10, 0) <= version and version < (11, 0): # Prior to Mac OS 11, each yearly release of Mac OS bumped the # "minor" version number. The major version was always 10. for minor_version in range(version[1], -1, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=10, minor=minor_version, binary_format=binary_format ) if version >= (11, 0): # Starting with Mac OS 11, each yearly release bumps the major version # number. The minor versions are now the midyear updates. for major_version in range(version[0], 10, -1): compat_version = major_version, 0 binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=major_version, minor=0, binary_format=binary_format ) if version >= (11, 0): # Mac OS 11 on x86_64 is compatible with binaries from previous releases. # Arm64 support was introduced in 11.0, so no Arm binaries from previous # releases exist. # # However, the "universal2" binary format can have a # macOS version earlier than 11.0 when the x86_64 part of the binary supports # that version of macOS. if arch == "x86_64": for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) else: for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_format = "universal2" yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: linux = _normalize_string(sysconfig.get_platform()) if is_32bit: if linux == "linux_x86_64": linux = "linux_i686" elif linux == "linux_aarch64": linux = "linux_armv7l" _, arch = linux.split("_", 1) yield from _manylinux.platform_tags(linux, arch) yield from _musllinux.platform_tags(arch) yield linux def _generic_platforms() -> Iterator[str]: yield _normalize_string(sysconfig.get_platform()) def platform_tags() -> Iterator[str]: """ Provides the platform tags for this installation. """ if platform.system() == "Darwin": return mac_platforms() elif platform.system() == "Linux": return _linux_platforms() else: return _generic_platforms() def interpreter_name() -> str: """ Returns the name of the running interpreter. """ name = sys.implementation.name return INTERPRETER_SHORT_NAMES.get(name) or name def interpreter_version(*, warn: bool = False) -> str: """ Returns the version of the running interpreter. """ version = _get_config_var("py_version_nodot", warn=warn) if version: version = str(version) else: version = _version_nodot(sys.version_info[:2]) return version def _version_nodot(version: PythonVersion) -> str: return "".join(map(str, version)) def sys_tags(*, warn: bool = False) -> Iterator[Tag]: """ Returns the sequence of tag triples for the running interpreter. The order of the sequence corresponds to priority order for the interpreter, from most to least important. """ interp_name = interpreter_name() if interp_name == "cp": yield from cpython_tags(warn=warn) else: yield from generic_tags() if interp_name == "pp": yield from compatible_tags(interpreter="pp3") else: yield from compatible_tags() __init__.py 0000644 00000000761 15030043575 0006663 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from .__about__ import ( __author__, __copyright__, __email__, __license__, __summary__, __title__, __uri__, __version__, ) __all__ = [ "__title__", "__summary__", "__uri__", "__version__", "__author__", "__email__", "__license__", "__copyright__", ] requirements.py 0000644 00000011104 15030064307 0007634 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import re import string import urllib.parse from typing import List, Optional as TOptional, Set from pip._vendor.pyparsing import ( # noqa Combine, Literal as L, Optional, ParseException, Regex, Word, ZeroOrMore, originalTextFor, stringEnd, stringStart, ) from .markers import MARKER_EXPR, Marker from .specifiers import LegacySpecifier, Specifier, SpecifierSet class InvalidRequirement(ValueError): """ An invalid requirement was found, users should refer to PEP 508. """ ALPHANUM = Word(string.ascii_letters + string.digits) LBRACKET = L("[").suppress() RBRACKET = L("]").suppress() LPAREN = L("(").suppress() RPAREN = L(")").suppress() COMMA = L(",").suppress() SEMICOLON = L(";").suppress() AT = L("@").suppress() PUNCTUATION = Word("-_.") IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM) IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END)) NAME = IDENTIFIER("name") EXTRA = IDENTIFIER URI = Regex(r"[^ ]+")("url") URL = AT + URI EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA) EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras") VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE) VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE) VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY VERSION_MANY = Combine( VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False )("_raw_spec") _VERSION_SPEC = Optional((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY) _VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "") VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier") VERSION_SPEC.setParseAction(lambda s, l, t: t[1]) MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker") MARKER_EXPR.setParseAction( lambda s, l, t: Marker(s[t._original_start : t._original_end]) ) MARKER_SEPARATOR = SEMICOLON MARKER = MARKER_SEPARATOR + MARKER_EXPR VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER) URL_AND_MARKER = URL + Optional(MARKER) NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER) REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd # pyparsing isn't thread safe during initialization, so we do it eagerly, see # issue #104 REQUIREMENT.parseString("x[]") class Requirement: """Parse a requirement. Parse a given requirement string into its parts, such as name, specifier, URL, and extras. Raises InvalidRequirement on a badly-formed requirement string. """ # TODO: Can we test whether something is contained within a requirement? # If so how do we do that? Do we need to test against the _name_ of # the thing as well as the version? What about the markers? # TODO: Can we normalize the name and extra name? def __init__(self, requirement_string: str) -> None: try: req = REQUIREMENT.parseString(requirement_string) except ParseException as e: raise InvalidRequirement( f'Parse error at "{ requirement_string[e.loc : e.loc + 8]!r}": {e.msg}' ) self.name: str = req.name if req.url: parsed_url = urllib.parse.urlparse(req.url) if parsed_url.scheme == "file": if urllib.parse.urlunparse(parsed_url) != req.url: raise InvalidRequirement("Invalid URL given") elif not (parsed_url.scheme and parsed_url.netloc) or ( not parsed_url.scheme and not parsed_url.netloc ): raise InvalidRequirement(f"Invalid URL: {req.url}") self.url: TOptional[str] = req.url else: self.url = None self.extras: Set[str] = set(req.extras.asList() if req.extras else []) self.specifier: SpecifierSet = SpecifierSet(req.specifier) self.marker: TOptional[Marker] = req.marker if req.marker else None def __str__(self) -> str: parts: List[str] = [self.name] if self.extras: formatted_extras = ",".join(sorted(self.extras)) parts.append(f"[{formatted_extras}]") if self.specifier: parts.append(str(self.specifier)) if self.url: parts.append(f"@ {self.url}") if self.marker: parts.append(" ") if self.marker: parts.append(f"; {self.marker}") return "".join(parts) def __repr__(self) -> str: return f"<Requirement('{self}')>" markers.py 0000644 00000020447 15030064307 0006567 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import operator import os import platform import sys from typing import Any, Callable, Dict, List, Optional, Tuple, Union from pip._vendor.pyparsing import ( # noqa: N817 Forward, Group, Literal as L, ParseException, ParseResults, QuotedString, ZeroOrMore, stringEnd, stringStart, ) from .specifiers import InvalidSpecifier, Specifier __all__ = [ "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName", "Marker", "default_environment", ] Operator = Callable[[str, str], bool] class InvalidMarker(ValueError): """ An invalid marker was found, users should refer to PEP 508. """ class UndefinedComparison(ValueError): """ An invalid operation was attempted on a value that doesn't support it. """ class UndefinedEnvironmentName(ValueError): """ A name was attempted to be used that does not exist inside of the environment. """ class Node: def __init__(self, value: Any) -> None: self.value = value def __str__(self) -> str: return str(self.value) def __repr__(self) -> str: return f"<{self.__class__.__name__}('{self}')>" def serialize(self) -> str: raise NotImplementedError class Variable(Node): def serialize(self) -> str: return str(self) class Value(Node): def serialize(self) -> str: return f'"{self}"' class Op(Node): def serialize(self) -> str: return str(self) VARIABLE = ( L("implementation_version") | L("platform_python_implementation") | L("implementation_name") | L("python_full_version") | L("platform_release") | L("platform_version") | L("platform_machine") | L("platform_system") | L("python_version") | L("sys_platform") | L("os_name") | L("os.name") # PEP-345 | L("sys.platform") # PEP-345 | L("platform.version") # PEP-345 | L("platform.machine") # PEP-345 | L("platform.python_implementation") # PEP-345 | L("python_implementation") # undocumented setuptools legacy | L("extra") # PEP-508 ) ALIASES = { "os.name": "os_name", "sys.platform": "sys_platform", "platform.version": "platform_version", "platform.machine": "platform_machine", "platform.python_implementation": "platform_python_implementation", "python_implementation": "platform_python_implementation", } VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0]))) VERSION_CMP = ( L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<") ) MARKER_OP = VERSION_CMP | L("not in") | L("in") MARKER_OP.setParseAction(lambda s, l, t: Op(t[0])) MARKER_VALUE = QuotedString("'") | QuotedString('"') MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0])) BOOLOP = L("and") | L("or") MARKER_VAR = VARIABLE | MARKER_VALUE MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR) MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0])) LPAREN = L("(").suppress() RPAREN = L(")").suppress() MARKER_EXPR = Forward() MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN) MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR) MARKER = stringStart + MARKER_EXPR + stringEnd def _coerce_parse_result(results: Union[ParseResults, List[Any]]) -> List[Any]: if isinstance(results, ParseResults): return [_coerce_parse_result(i) for i in results] else: return results def _format_marker( marker: Union[List[str], Tuple[Node, ...], str], first: Optional[bool] = True ) -> str: assert isinstance(marker, (list, tuple, str)) # Sometimes we have a structure like [[...]] which is a single item list # where the single item is itself it's own list. In that case we want skip # the rest of this function so that we don't get extraneous () on the # outside. if ( isinstance(marker, list) and len(marker) == 1 and isinstance(marker[0], (list, tuple)) ): return _format_marker(marker[0]) if isinstance(marker, list): inner = (_format_marker(m, first=False) for m in marker) if first: return " ".join(inner) else: return "(" + " ".join(inner) + ")" elif isinstance(marker, tuple): return " ".join([m.serialize() for m in marker]) else: return marker _operators: Dict[str, Operator] = { "in": lambda lhs, rhs: lhs in rhs, "not in": lambda lhs, rhs: lhs not in rhs, "<": operator.lt, "<=": operator.le, "==": operator.eq, "!=": operator.ne, ">=": operator.ge, ">": operator.gt, } def _eval_op(lhs: str, op: Op, rhs: str) -> bool: try: spec = Specifier("".join([op.serialize(), rhs])) except InvalidSpecifier: pass else: return spec.contains(lhs) oper: Optional[Operator] = _operators.get(op.serialize()) if oper is None: raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") return oper(lhs, rhs) class Undefined: pass _undefined = Undefined() def _get_env(environment: Dict[str, str], name: str) -> str: value: Union[str, Undefined] = environment.get(name, _undefined) if isinstance(value, Undefined): raise UndefinedEnvironmentName( f"{name!r} does not exist in evaluation environment." ) return value def _evaluate_markers(markers: List[Any], environment: Dict[str, str]) -> bool: groups: List[List[bool]] = [[]] for marker in markers: assert isinstance(marker, (list, tuple, str)) if isinstance(marker, list): groups[-1].append(_evaluate_markers(marker, environment)) elif isinstance(marker, tuple): lhs, op, rhs = marker if isinstance(lhs, Variable): lhs_value = _get_env(environment, lhs.value) rhs_value = rhs.value else: lhs_value = lhs.value rhs_value = _get_env(environment, rhs.value) groups[-1].append(_eval_op(lhs_value, op, rhs_value)) else: assert marker in ["and", "or"] if marker == "or": groups.append([]) return any(all(item) for item in groups) def format_full_version(info: "sys._version_info") -> str: version = "{0.major}.{0.minor}.{0.micro}".format(info) kind = info.releaselevel if kind != "final": version += kind[0] + str(info.serial) return version def default_environment() -> Dict[str, str]: iver = format_full_version(sys.implementation.version) implementation_name = sys.implementation.name return { "implementation_name": implementation_name, "implementation_version": iver, "os_name": os.name, "platform_machine": platform.machine(), "platform_release": platform.release(), "platform_system": platform.system(), "platform_version": platform.version(), "python_full_version": platform.python_version(), "platform_python_implementation": platform.python_implementation(), "python_version": ".".join(platform.python_version_tuple()[:2]), "sys_platform": sys.platform, } class Marker: def __init__(self, marker: str) -> None: try: self._markers = _coerce_parse_result(MARKER.parseString(marker)) except ParseException as e: raise InvalidMarker( f"Invalid marker: {marker!r}, parse error at " f"{marker[e.loc : e.loc + 8]!r}" ) def __str__(self) -> str: return _format_marker(self._markers) def __repr__(self) -> str: return f"<Marker('{self}')>" def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool: """Evaluate a marker. Return the boolean from evaluating the given marker against the environment. environment is an optional argument to override all or part of the determined environment. The environment is determined from the current Python process. """ current_environment = default_environment() if environment is not None: current_environment.update(environment) return _evaluate_markers(self._markers, current_environment) _manylinux.py 0000644 00000026340 15030064307 0007304 0 ustar 00 import collections import functools import os import re import struct import sys import warnings from typing import IO, Dict, Iterator, NamedTuple, Optional, Tuple # Python does not provide platform information at sufficient granularity to # identify the architecture of the running executable in some cases, so we # determine it dynamically by reading the information from the running # process. This only applies on Linux, which uses the ELF format. class _ELFFileHeader: # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header class _InvalidELFFileHeader(ValueError): """ An invalid ELF file header was found. """ ELF_MAGIC_NUMBER = 0x7F454C46 ELFCLASS32 = 1 ELFCLASS64 = 2 ELFDATA2LSB = 1 ELFDATA2MSB = 2 EM_386 = 3 EM_S390 = 22 EM_ARM = 40 EM_X86_64 = 62 EF_ARM_ABIMASK = 0xFF000000 EF_ARM_ABI_VER5 = 0x05000000 EF_ARM_ABI_FLOAT_HARD = 0x00000400 def __init__(self, file: IO[bytes]) -> None: def unpack(fmt: str) -> int: try: data = file.read(struct.calcsize(fmt)) result: Tuple[int, ...] = struct.unpack(fmt, data) except struct.error: raise _ELFFileHeader._InvalidELFFileHeader() return result[0] self.e_ident_magic = unpack(">I") if self.e_ident_magic != self.ELF_MAGIC_NUMBER: raise _ELFFileHeader._InvalidELFFileHeader() self.e_ident_class = unpack("B") if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}: raise _ELFFileHeader._InvalidELFFileHeader() self.e_ident_data = unpack("B") if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}: raise _ELFFileHeader._InvalidELFFileHeader() self.e_ident_version = unpack("B") self.e_ident_osabi = unpack("B") self.e_ident_abiversion = unpack("B") self.e_ident_pad = file.read(7) format_h = "<H" if self.e_ident_data == self.ELFDATA2LSB else ">H" format_i = "<I" if self.e_ident_data == self.ELFDATA2LSB else ">I" format_q = "<Q" if self.e_ident_data == self.ELFDATA2LSB else ">Q" format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q self.e_type = unpack(format_h) self.e_machine = unpack(format_h) self.e_version = unpack(format_i) self.e_entry = unpack(format_p) self.e_phoff = unpack(format_p) self.e_shoff = unpack(format_p) self.e_flags = unpack(format_i) self.e_ehsize = unpack(format_h) self.e_phentsize = unpack(format_h) self.e_phnum = unpack(format_h) self.e_shentsize = unpack(format_h) self.e_shnum = unpack(format_h) self.e_shstrndx = unpack(format_h) def _get_elf_header() -> Optional[_ELFFileHeader]: try: with open(sys.executable, "rb") as f: elf_header = _ELFFileHeader(f) except (OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader): return None return elf_header def _is_linux_armhf() -> bool: # hard-float ABI can be detected from the ELF header of the running # process # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf elf_header = _get_elf_header() if elf_header is None: return False result = elf_header.e_ident_class == elf_header.ELFCLASS32 result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB result &= elf_header.e_machine == elf_header.EM_ARM result &= ( elf_header.e_flags & elf_header.EF_ARM_ABIMASK ) == elf_header.EF_ARM_ABI_VER5 result &= ( elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD ) == elf_header.EF_ARM_ABI_FLOAT_HARD return result def _is_linux_i686() -> bool: elf_header = _get_elf_header() if elf_header is None: return False result = elf_header.e_ident_class == elf_header.ELFCLASS32 result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB result &= elf_header.e_machine == elf_header.EM_386 return result def _have_compatible_abi(arch: str) -> bool: if arch == "armv7l": return _is_linux_armhf() if arch == "i686": return _is_linux_i686() return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"} # If glibc ever changes its major version, we need to know what the last # minor version was, so we can build the complete list of all versions. # For now, guess what the highest minor version might be, assume it will # be 50 for testing. Once this actually happens, update the dictionary # with the actual value. _LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50) class _GLibCVersion(NamedTuple): major: int minor: int def _glibc_version_string_confstr() -> Optional[str]: """ Primary implementation of glibc_version_string using os.confstr. """ # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely # to be broken or missing. This strategy is used in the standard library # platform module. # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183 try: # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17". version_string = os.confstr("CS_GNU_LIBC_VERSION") assert version_string is not None _, version = version_string.split() except (AssertionError, AttributeError, OSError, ValueError): # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... return None return version def _glibc_version_string_ctypes() -> Optional[str]: """ Fallback implementation of glibc_version_string using ctypes. """ try: import ctypes except ImportError: return None # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen # manpage says, "If filename is NULL, then the returned handle is for the # main program". This way we can let the linker do the work to figure out # which libc our process is actually using. # # We must also handle the special case where the executable is not a # dynamically linked executable. This can occur when using musl libc, # for example. In this situation, dlopen() will error, leading to an # OSError. Interestingly, at least in the case of musl, there is no # errno set on the OSError. The single string argument used to construct # OSError comes from libc itself and is therefore not portable to # hard code here. In any case, failure to call dlopen() means we # can proceed, so we bail on our attempt. try: process_namespace = ctypes.CDLL(None) except OSError: return None try: gnu_get_libc_version = process_namespace.gnu_get_libc_version except AttributeError: # Symbol doesn't exist -> therefore, we are not linked to # glibc. return None # Call gnu_get_libc_version, which returns a string like "2.5" gnu_get_libc_version.restype = ctypes.c_char_p version_str: str = gnu_get_libc_version() # py2 / py3 compatibility: if not isinstance(version_str, str): version_str = version_str.decode("ascii") return version_str def _glibc_version_string() -> Optional[str]: """Returns glibc version string, or None if not using glibc.""" return _glibc_version_string_confstr() or _glibc_version_string_ctypes() def _parse_glibc_version(version_str: str) -> Tuple[int, int]: """Parse glibc version. We use a regexp instead of str.split because we want to discard any random junk that might come after the minor version -- this might happen in patched/forked versions of glibc (e.g. Linaro's version of glibc uses version strings like "2.20-2014.11"). See gh-3588. """ m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str) if not m: warnings.warn( "Expected glibc version with 2 components major.minor," " got: %s" % version_str, RuntimeWarning, ) return -1, -1 return int(m.group("major")), int(m.group("minor")) @functools.lru_cache() def _get_glibc_version() -> Tuple[int, int]: version_str = _glibc_version_string() if version_str is None: return (-1, -1) return _parse_glibc_version(version_str) # From PEP 513, PEP 600 def _is_compatible(name: str, arch: str, version: _GLibCVersion) -> bool: sys_glibc = _get_glibc_version() if sys_glibc < version: return False # Check for presence of _manylinux module. try: import _manylinux # noqa except ImportError: return True if hasattr(_manylinux, "manylinux_compatible"): result = _manylinux.manylinux_compatible(version[0], version[1], arch) if result is not None: return bool(result) return True if version == _GLibCVersion(2, 5): if hasattr(_manylinux, "manylinux1_compatible"): return bool(_manylinux.manylinux1_compatible) if version == _GLibCVersion(2, 12): if hasattr(_manylinux, "manylinux2010_compatible"): return bool(_manylinux.manylinux2010_compatible) if version == _GLibCVersion(2, 17): if hasattr(_manylinux, "manylinux2014_compatible"): return bool(_manylinux.manylinux2014_compatible) return True _LEGACY_MANYLINUX_MAP = { # CentOS 7 w/ glibc 2.17 (PEP 599) (2, 17): "manylinux2014", # CentOS 6 w/ glibc 2.12 (PEP 571) (2, 12): "manylinux2010", # CentOS 5 w/ glibc 2.5 (PEP 513) (2, 5): "manylinux1", } def platform_tags(linux: str, arch: str) -> Iterator[str]: if not _have_compatible_abi(arch): return # Oldest glibc to be supported regardless of architecture is (2, 17). too_old_glibc2 = _GLibCVersion(2, 16) if arch in {"x86_64", "i686"}: # On x86/i686 also oldest glibc to be supported is (2, 5). too_old_glibc2 = _GLibCVersion(2, 4) current_glibc = _GLibCVersion(*_get_glibc_version()) glibc_max_list = [current_glibc] # We can assume compatibility across glibc major versions. # https://sourceware.org/bugzilla/show_bug.cgi?id=24636 # # Build a list of maximum glibc versions so that we can # output the canonical list of all glibc from current_glibc # down to too_old_glibc2, including all intermediary versions. for glibc_major in range(current_glibc.major - 1, 1, -1): glibc_minor = _LAST_GLIBC_MINOR[glibc_major] glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor)) for glibc_max in glibc_max_list: if glibc_max.major == too_old_glibc2.major: min_minor = too_old_glibc2.minor else: # For other glibc major versions oldest supported is (x, 0). min_minor = -1 for glibc_minor in range(glibc_max.minor, min_minor, -1): glibc_version = _GLibCVersion(glibc_max.major, glibc_minor) tag = "manylinux_{}_{}".format(*glibc_version) if _is_compatible(tag, arch, glibc_version): yield linux.replace("linux", tag) # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags. if glibc_version in _LEGACY_MANYLINUX_MAP: legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version] if _is_compatible(legacy_tag, arch, glibc_version): yield linux.replace("linux", legacy_tag) __pycache__/_manylinux.cpython-310.pyc 0000644 00000016140 15030064307 0013640 0 ustar 00 o �7]h�, � @ s� U d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZm Z m Z m Z m Z m Z G dd� d�Zde e fdd�Zdefdd �Zdefd d �Zd edefd d�Ze �dd� �Ze eef ed< G dd� de �Zde e fdd�Zde e fdd�Zde e fdd�Z dede eef fdd �Z e� � de eef fd d ��Z d ed ed edefd!d"�Z d#d$d%d&�Z!d'ed ede e fd(d)�Z"dS )*� N)�IO�Dict�Iterator� NamedTuple�Optional�Tuplec @ sb e Zd ZG dd� de�ZdZdZdZdZdZ dZ dZ dZ d Z d Zd Zd Zd ee ddfdd�ZdS )�_ELFFileHeaderc @ s e Zd ZdZdS )z$_ELFFileHeader._InvalidELFFileHeaderz7 An invalid ELF file header was found. N)�__name__� __module__� __qualname__�__doc__� r r �B/usr/lib/python3/dist-packages/pip/_vendor/packaging/_manylinux.py�_InvalidELFFileHeader s r iFLE� � � � �( �> l ~ i i �file�returnNc s| dt dtf� fdd� }|d�| _| j| jkrt�� �|d�| _| j| j| jhvr,t�� �|d�| _ | j | j | j hvr>t�� �|d�| _ |d�| _ |d�| _� �d�| _| j | j kr[dnd }| j | j kred nd}| j | j krod nd }| j| jkry|n|}||�| _||�| _||�| _||�| _||�| _||�| _||�| _||�| _||�| _||�| _||�| _||�| _ ||�| _ d S ) N�fmtr c s@ z� � t�| ��}t�| |�}W |d S tjy t�� �w )Nr )�read�struct�calcsize�unpack�errorr r )r �data�result�r r r r $ s ��z'_ELFFileHeader.__init__.<locals>.unpackz>I�B� z<Hz>Hz<Iz<Qz>Q) �str�int� e_ident_magic�ELF_MAGIC_NUMBERr r � e_ident_class� ELFCLASS32� ELFCLASS64� e_ident_data� ELFDATA2LSB� ELFDATA2MSB�e_ident_version� e_ident_osabi�e_ident_abiversionr � e_ident_pad�e_type� e_machine� e_version�e_entry�e_phoff�e_shoff�e_flags�e_ehsize� e_phentsize�e_phnum� e_shentsize�e_shnum� e_shstrndx)�selfr r �format_h�format_i�format_q�format_pr r r �__init__# s> z_ELFFileHeader.__init__)r r r � ValueErrorr r& r( r) r+ r, �EM_386�EM_S390�EM_ARM� EM_X86_64�EF_ARM_ABIMASK�EF_ARM_ABI_VER5�EF_ARM_ABI_FLOAT_HARDr �bytesrC r r r r r s r r c C s\ z t tjd��} t| �}W d � W |S 1 sw Y W |S tttjfy- Y d S w )N�rb)�open�sys� executabler �OSError� TypeErrorr )�f� elf_headerr r r �_get_elf_headerL s ����rU c C sn t � } | d u r dS | j| jk}|| j| jkM }|| j| jkM }|| j| j@ | j kM }|| j| j @ | j kM }|S �NF) rU r' r( r* r+ r2 rG r7 rI rJ rK �rT r r r r �_is_linux_armhfU s � �rX c C sB t � } | d u r dS | j| jk}|| j| jkM }|| j| jkM }|S rV )rU r' r( r* r+ r2 rE rW r r r �_is_linux_i686h s rY �archc C s$ | dkrt � S | dkrt� S | dv S )N�armv7l�i686> �ppc64�s390x�x86_64�aarch64�ppc64le)rX rY )rZ r r r �_have_compatible_abir s rb c C s dS )N�2 r r r r r �<lambda> s rd �_LAST_GLIBC_MINORc @ s e Zd ZU eed< eed< dS )� _GLibCVersion�major�minorN)r r r r$ �__annotations__r r r r rf � s rf c C sF zt �d�} | dus J �| �� \}}W |S ttttfy" Y dS w )zJ Primary implementation of glibc_version_string using os.confstr. �CS_GNU_LIBC_VERSIONN)�os�confstr�split�AssertionError�AttributeErrorrQ rD )�version_string�_�versionr r r � _glibc_version_string_confstr� s ��rs c C s� zddl } W n ty Y dS w z| �d�}W n ty" Y dS w z|j}W n ty2 Y dS w | j|_|� }t|t �sD|� d�}|S )zG Fallback implementation of glibc_version_string using ctypes. r N�ascii) �ctypes� ImportError�CDLLrQ �gnu_get_libc_versionro �c_char_p�restype� isinstancer# �decode)ru �process_namespacerx � version_strr r r � _glibc_version_string_ctypes� s( � � � r c C s t � pt� S )z9Returns glibc version string, or None if not using glibc.)rs r r r r r �_glibc_version_string� s r� r~ c C s@ t �d| �}|st�d| t� dS t|�d��t|�d��fS )a3 Parse glibc version. We use a regexp instead of str.split because we want to discard any random junk that might come after the minor version -- this might happen in patched/forked versions of glibc (e.g. Linaro's version of glibc uses version strings like "2.20-2014.11"). See gh-3588. z$(?P<major>[0-9]+)\.(?P<minor>[0-9]+)z=Expected glibc version with 2 components major.minor, got: %s����r� rg rh )�re�match�warnings�warn�RuntimeWarningr$ �group)r~ �mr r r �_parse_glibc_version� s �� r� c C s t � } | d u r dS t| �S )Nr� )r� r� )r~ r r r �_get_glibc_version� s r� �namerr c C s� t � }||k r dS zdd l}W n ty Y dS w t|d�r4|�|d |d |�}|d ur2t|�S dS |tdd�krEt|d�rEt|j�S |tdd �krVt|d �rVt|j�S |tdd �krgt|d �rgt|j �S dS ) NFr T�manylinux_compatibler r � �manylinux1_compatible� �manylinux2010_compatible� �manylinux2014_compatible) r� � _manylinuxrv �hasattrr� �boolrf r� r� r� )r� rZ rr � sys_glibcr� r r r r �_is_compatible� s. � r� � manylinux2014� manylinux2010� manylinux1))r r� )r r� )r r� �linuxc c s� � t |�sd S tdd�}|dv rtdd�}tt� � }|g}t|jd dd�D ]}t| }|�t||�� q&|D ]E}|j|jkrC|j}nd}t|j|d�D ]/}t|j|�} dj| � } t | || �rf| � d| �V | t v r{t | } t | || �r{| � d| �V qLq7d S ) Nr � > r\ r_ � r r� zmanylinux_{}_{}r� ) rb rf r� �rangerg re �appendrh �formatr� �replace�_LEGACY_MANYLINUX_MAP) r� rZ �too_old_glibc2� current_glibc�glibc_max_list� glibc_major� glibc_minor� glibc_max� min_minor� glibc_version�tag� legacy_tagr r r � platform_tags s6 � ���r� )#� collections� functoolsrk r� r rO r� �typingr r r r r r r rU r� rX rY r# rb � defaultdictre r$ ri rf rs r r� r� � lru_cacher� r� r� r� r r r r �<module> s6 = , � __pycache__/markers.cpython-310.pyc 0000644 00000022043 15030064307 0013120 0 ustar 00 o �7]h'! � @ s� U d dl Z d dlZd dlZd dlZd dlmZmZmZmZm Z m Z m Z d dl m Z mZmZmZmZmZmZmZmZ ddlmZmZ g d�Zeeege f Z G dd� de �Z G d d � d e �Z G d d � d e �Z!G d d� d�Z"G dd� de"�Z#G dd� de"�Z$G dd� de"�Z%ed�ed�B ed�B ed�B ed�B ed�B ed�B ed �B ed �B ed �B ed �B ed �B ed!�B ed"�B ed#�B ed$�B ed%�B ed&�B Z&d d ddddd'�Z'e&�(d(d)� � ed*�ed+�B ed,�B ed-�B ed.�B ed/�B ed0�B ed1�B Z)e)ed2�B ed3�B Z*e*�(d4d)� � ed5�ed6�B Z+e+�(d7d)� � ed8�ed9�B Z,e&e+B Z-ee-e* e- �Z.e.�(d:d)� � ed;��/� Z0ed<��/� Z1e � Z2e.ee0e2 e1 �B Z3e2e3ee,e2 � > ee2 e Z4d=e eee f d>ee fd?d@�Z5 AdadBe ee e e"dCf ef dDe e d>efdEdF�Z6dGd)� dHd)� e j7e j8e j9e j:e j;e j<dI�Z=eee f e>dJ< dKedLe%dMed>e fdNdO�Z?G dPdQ� dQ�Z@e@� ZAdReeef dSed>efdTdU�ZBdVee dReeef d>e fdWdX�ZCdYdZd>efd[d\�ZDd>eeef fd]d^�ZEG d_d`� d`�ZFdS )b� N)�Any�Callable�Dict�List�Optional�Tuple�Union) �Forward�Group�Literal�ParseException� ParseResults� QuotedString� ZeroOrMore� stringEnd� stringStart� )�InvalidSpecifier� Specifier)� InvalidMarker�UndefinedComparison�UndefinedEnvironmentName�Marker�default_environmentc @ � e Zd ZdZdS )r zE An invalid marker was found, users should refer to PEP 508. N��__name__� __module__� __qualname__�__doc__� r r �?/usr/lib/python3/dist-packages/pip/_vendor/packaging/markers.pyr $ � r c @ r )r zP An invalid operation was attempted on a value that doesn't support it. Nr r r r r! r * r" r c @ r )r z\ A name was attempted to be used that does not exist inside of the environment. Nr r r r r! r 0 r" r c @ sH e Zd Zdeddfdd�Zdefdd�Zdefdd �Zdefd d �ZdS ) �Node�value�returnNc C s || _ d S �N)r$ )�selfr$ r r r! �__init__8 � z Node.__init__c C � t | j�S r& )�strr$ �r' r r r! �__str__; r) z Node.__str__c C s d| j j� d| � d�S )N�<z('�')>)� __class__r r, r r r! �__repr__> s z Node.__repr__c C s t �r& )�NotImplementedErrorr, r r r! � serializeA s zNode.serialize) r r r r r( r+ r- r1 r3 r r r r! r# 7 s r# c @ � e Zd Zdefdd�ZdS )�Variabler% c C � t | �S r& �r+ r, r r r! r3 F � zVariable.serializeN�r r r r+ r3 r r r r! r5 E � r5 c @ r4 )�Valuer% c C s d| � d�S )N�"r r, r r r! r3 K � zValue.serializeNr9 r r r r! r; J r: r; c @ r4 )�Opr% c C r6 r& r7 r, r r r! r3 P r8 z Op.serializeNr9 r r r r! r> O r: r> �implementation_version� platform_python_implementation�implementation_name�python_full_version�platform_release�platform_version�platform_machine�platform_system�python_version� sys_platform�os_name�os.name� sys.platform�platform.version�platform.machine� platform.python_implementation�python_implementation�extra)rJ rK rL rM rN rO c C s t t�|d |d ��S �Nr )r5 �ALIASES�get��s�l�tr r r! �<lambda>p s rX z===�==�>=�<=�!=z~=�>r. �not in�inc C � t |d �S rQ )r> rT r r r! rX w � �'r< c C r` rQ )r; rT r r r! rX z ra �and�orc C r` rQ )�tuplerT r r r! rX � ra �(�)�resultsr% c C s t | t�r dd� | D �S | S )Nc S s g | ]}t |��qS r )�_coerce_parse_result)�.0�ir r r! � <listcomp>� � z(_coerce_parse_result.<locals>.<listcomp>)� isinstancer )rh r r r! ri � s ri T�marker.�firstc C s� t | tttf�s J �t | t�r$t| �dkr$t | d ttf�r$t| d �S t | t�r@dd� | D �}|r7d�|�S dd�|� d S t | t�rOd�dd � | D ��S | S ) Nr r c s s � | ] }t |d d�V qdS )F)rp N)�_format_marker�rj �mr r r! � <genexpr>� s � z!_format_marker.<locals>.<genexpr>� rf rg c S s g | ]}|� � �qS r )r3 rr r r r! rl � rm z"_format_marker.<locals>.<listcomp>)rn �listre r+ �lenrq �join)ro rp �innerr r r! rq � s � � rq c C s | |v S r& r ��lhs�rhsr r r! rX � � c C s | |vS r& r rz r r r! rX � r} )r_ r^ r. r[ rY r\ rZ r] � _operatorsr{ �opr| c C st z t d�|�� |g��}W n ty Y nw |�| �S t�|�� �}|d u r5td|�d| �d|�d���|| |�S )N� z Undefined z on z and �.)r rx r3 r �containsr~ rS r )r{ r r| �spec�operr r r! �_eval_op� s � r� c @ s e Zd ZdS )� UndefinedN)r r r r r r r! r� � s r� � environment�namec C s( | � |t�}t|t�rt|�d���|S )Nz* does not exist in evaluation environment.)rS � _undefinedrn r� r )r� r� r$ r r r! �_get_env� s �r� �markersc C s� g g}| D ]Y}t |tttf�sJ �t |t�r!|d �t||�� qt |t�rO|\}}}t |t�r:t||j�}|j}n |j}t||j�}|d �t |||�� q|dv sUJ �|dkr^|�g � qt dd� |D ��S )N���)rc rd rd c s s � | ]}t |�V qd S r& )�all)rj �itemr r r! rt � s � z$_evaluate_markers.<locals>.<genexpr>) rn rv re r+ �append�_evaluate_markersr5 r� r$ r� �any) r� r� �groupsro r{ r r| � lhs_value� rhs_valuer r r! r� � s$ �r� �infozsys._version_infoc C s2 d� | �}| j}|dkr||d t| j� 7 }|S )Nz {0.major}.{0.minor}.{0.micro}�finalr )�format� releaselevelr+ �serial)r� �version�kindr r r! �format_full_version� s r� c C s^ t tjj�} tjj}|| tjt�� t�� t� � t�� t� � t� � d� t� � d d� �tjd� S )Nr� � ) rA r? rI rE rC rF rD rB r@ rG rH )r� �sys�implementationr� r� �os�platform�machine�release�systemrG rO rx �python_version_tuple)�iverrA r r r! r s �r c @ sZ e Zd Zdeddfdd�Zdefdd�Zdefdd �Zd d eeeef de fd d �Z dS )r ro r% Nc C sT z t t�|��| _W d S ty) } ztd|�d||j|jd � ����d }~ww )NzInvalid marker: z, parse error at � )ri �MARKER� parseString�_markersr r �loc)r' ro �er r r! r( s ����zMarker.__init__c C r* r& )rq r� r, r r r! r- r) zMarker.__str__c C s d| � d�S )Nz <Marker('r/ r r, r r r! r1 r= zMarker.__repr__r� c C s$ t � }|dur |�|� t| j|�S )a$ Evaluate a marker. Return the boolean from evaluating the given marker against the environment. environment is an optional argument to override all or part of the determined environment. The environment is determined from the current Python process. N)r �updater� r� )r' r� �current_environmentr r r! �evaluate# s zMarker.evaluater& ) r r r r+ r( r- r1 r r �boolr� r r r r! r s $r )T)G�operatorr� r� r� �typingr r r r r r r �pip._vendor.pyparsingr r r �Lr r r r r r � specifiersr r �__all__r+ r� �Operator� ValueErrorr r r r# r5 r; r> �VARIABLErR �setParseAction� VERSION_CMP� MARKER_OP� MARKER_VALUE�BOOLOP� MARKER_VAR� MARKER_ITEM�suppress�LPAREN�RPAREN� MARKER_EXPR� MARKER_ATOMr� ri rq �lt�le�eq�ne�ge�gtr~ �__annotations__r� r� r� r� r� r� r r r r r r! �<module> s� $, �������� � � � � �������>� "��� � � " __pycache__/version.cpython-310.pyc 0000644 00000031131 15030064307 0013137 0 ustar 00 o �7]hI9 � @ sh d dl Z d dlZd dlZd dlZd dlmZmZmZmZm Z m Z m Z ddl m Z mZmZmZ g d�Ze eef Ze ee eef f Ze eeef Ze ee e ee eef e eef f df f Ze ee edf eeeef Ze ee edf f Zee eef e eef gef Ze � dg d��Z d ed e d fd d �Z G dd� de �Z G dd� d�Z!G dd� de!�Z"e�#dej$�Z%dddddd�Z&ded ee fdd�Z'd ed efd d �Z(d Z)G d d � d e!�Z*d!ed"e ee+e f d ee eef fd#d$�Z,e�#d%�Z-d&ed ee fd'd(�Z.d)ed*e edf d+ee eef d,ee eef d-ee eef d&ee e d efd.d/�Z/dS )0� N)�Callable�Iterator�List�Optional� SupportsInt�Tuple�Union� )�Infinity� InfinityType�NegativeInfinity�NegativeInfinityType)�parse�Version� LegacyVersion�InvalidVersion�VERSION_PATTERN.�_Version)�epoch�release�dev�pre�post�local�version�return)r r c C s& zt | �W S ty t| � Y S w )z� Parse the given version string and return either a :class:`Version` object or a :class:`LegacyVersion` object depending on if the given version is a valid PEP 440 version or a legacy version. )r r r )r � r �?/usr/lib/python3/dist-packages/pip/_vendor/packaging/version.pyr * s �r c @ s e Zd ZdZdS )r zF An invalid version was found, users should refer to PEP 440. N)�__name__� __module__� __qualname__�__doc__r r r r r 6 s r c @ s� e Zd ZU eeef ed< defdd�Zdd de fdd�Z dd de fdd �Z de de fd d �Z dd de fd d �Zdd de fdd�Zde de fdd�ZdS )� _BaseVersion�_keyr c C s t | j�S �N)�hashr# ��selfr r r �__hash__? s z_BaseVersion.__hash__�otherc C s t |t�stS | j|jk S r$ �� isinstancer" �NotImplementedr# �r' r) r r r �__lt__E � z_BaseVersion.__lt__c C s t |t�stS | j|jkS r$ r* r- r r r �__le__K r/ z_BaseVersion.__le__c C s t |t�stS | j|jkS r$ r* r- r r r �__eq__Q r/ z_BaseVersion.__eq__c C s t |t�stS | j|jkS r$ r* r- r r r �__ge__W r/ z_BaseVersion.__ge__c C s t |t�stS | j|jkS r$ r* r- r r r �__gt__] r/ z_BaseVersion.__gt__c C s t |t�stS | j|jkS r$ r* r- r r r �__ne__c r/ z_BaseVersion.__ne__N)r r r r �CmpKey� LegacyCmpKey�__annotations__�intr( �boolr. r0 �objectr1 r2 r3 r4 r r r r r" < s r" c @ s� e Zd Zdeddfdd�Zdefdd�Zdefdd �Zedefd d ��Zedefd d ��Z ede fdd��Z ed dd��Z ed dd��Z ed dd��Zed dd��Zed dd��Zedefdd��Zedefd d ��Zedefd d ��ZdS )!r r r Nc C s& t |�| _t| j�| _t�dt� d S )NzZCreating a LegacyVersion has been deprecated and will be removed in the next major release)�str�_version�_legacy_cmpkeyr# �warnings�warn�DeprecationWarning)r' r r r r �__init__k s �zLegacyVersion.__init__c C � | j S r$ �r< r& r r r �__str__u s zLegacyVersion.__str__c C � d| � d�S )Nz<LegacyVersion('�')>r r& r r r �__repr__x � zLegacyVersion.__repr__c C rB r$ rC r& r r r �public{ � zLegacyVersion.publicc C rB r$ rC r& r r r � base_version rJ zLegacyVersion.base_versionc C � dS )N���r r& r r r r � � zLegacyVersion.epochc C � d S r$ r r& r r r r � rN zLegacyVersion.releasec C rO r$ r r& r r r r � rN zLegacyVersion.prec C rO r$ r r& r r r r � rN zLegacyVersion.postc C rO r$ r r& r r r r � rN zLegacyVersion.devc C rO r$ r r& r r r r � rN zLegacyVersion.localc C rL �NFr r& r r r � is_prerelease� rN zLegacyVersion.is_prereleasec C rL rP r r& r r r �is_postrelease� rN z LegacyVersion.is_postreleasec C rL rP r r& r r r � is_devrelease� rN zLegacyVersion.is_devrelease)r N)r r r r; rA rD rG �propertyrI rK r8 r r r r r r r9 rQ rR rS r r r r r j s4 r z(\d+ | [a-z]+ | \.| -)�czfinal-�@)r �preview�-�rcr �sc c s^ � t �| �D ]#}t�||�}|r|dkrq|d d� dv r$|�d�V qd| V qdV d S )N�.r � 0123456789� �*�*final)� _legacy_version_component_re�split� _legacy_version_replacement_map�get�zfill)rZ �partr r r �_parse_version_parts� s � rf c C s� d}g }t | �� �D ]8}|�d�r=|dk r)|r)|d dkr)|�� |r)|d dks |r=|d dkr=|�� |r=|d dks1|�|� q |t|�fS )NrM r^ r_ z*final-�00000000)rf �lower� startswith�pop�append�tuple)r r �partsre r r r r= � s �� r= a� v? (?: (?:(?P<epoch>[0-9]+)!)? # epoch (?P<release>[0-9]+(?:\.[0-9]+)*) # release segment (?P<pre> # pre-release [-_\.]? (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview)) [-_\.]? (?P<pre_n>[0-9]+)? )? (?P<post> # post release (?:-(?P<post_n1>[0-9]+)) | (?: [-_\.]? (?P<post_l>post|rev|r) [-_\.]? (?P<post_n2>[0-9]+)? ) )? (?P<dev> # dev release [-_\.]? (?P<dev_l>dev) [-_\.]? (?P<dev_n>[0-9]+)? )? ) (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version c @ sr e Zd Ze�de d ejejB �Zde ddfdd�Z de fdd �Z de fd d �Z e defd d ��Ze deedf fdd��Ze deee ef fdd��Ze dee fdd��Ze dee fdd��Ze dee fdd��Ze de fdd��Ze de fdd ��Ze defd d ��Ze defd d ��Ze defd!d"��Z e defd#d$��Z e defd%d&��Z e defd'd(��Z dS ))r z^\s*z\s*$r r Nc C s� | j �|�}|std|� d���t|�d�r t|�d��ndtdd� |�d��d�D ��t|�d �|�d ��t|�d �|�d �pD|�d ��t|�d�|�d��t |�d��d�| _ t | j j | j j | j j| j j| j j| j j�| _d S )NzInvalid version: '�'r r c s � � | ]}t |�V qd S r$ )r8 ��.0�ir r r � <genexpr> � � z#Version.__init__.<locals>.<genexpr>r r[ �pre_l�pre_n�post_l�post_n1�post_n2�dev_l�dev_nr )r r r r r r )�_regex�searchr r �groupr8 rl ra �_parse_letter_version�_parse_local_versionr< �_cmpkeyr r r r r r r# )r' r �matchr r r rA s* � � �zVersion.__init__c C rE )Nz <Version('rF r r& r r r rG " rH zVersion.__repr__c C s� g }| j dkr|�| j � d�� |�d�dd� | jD ��� | jd ur1|�d�dd� | jD ��� | jd ur?|�d| j� �� | jd urM|�d | j� �� | jd ur[|�d | j� �� d�|�S ) Nr �!r[ c s ro r$ �r; �rq �xr r r rs - rt z"Version.__str__.<locals>.<genexpr>� c s ro r$ r� r� r r r rs 1 rt z.postz.dev�+)r rk �joinr r r r r �r' rm r r r rD % s zVersion.__str__c C � | j j}|S r$ )r< r )r' �_epochr r r r A � z Version.epoch.c C r� r$ )r< r )r' �_releaser r r r F r� zVersion.releasec C r� r$ )r< r )r' �_prer r r r K r� z Version.prec C � | j jr | j jd S d S �Nr )r< r r& r r r r P � z Version.postc C r� r� )r< r r& r r r r T r� z Version.devc C s$ | j jrd�dd� | j jD ��S d S )Nr[ c s ro r$ r� r� r r r rs [ rt z Version.local.<locals>.<genexpr>)r< r r� r& r r r r X s z Version.localc C s t | ��dd�d S )Nr� r r )r; ra r& r r r rI _ � zVersion.publicc C sF g }| j dkr|�| j � d�� |�d�dd� | jD ��� d�|�S )Nr r� r[ c s ro r$ r� r� r r r rs l rt z'Version.base_version.<locals>.<genexpr>r� )r rk r� r r� r r r rK c s zVersion.base_versionc C s | j d up | jd uS r$ )r r r& r r r rQ p r� zVersion.is_prereleasec C � | j d uS r$ )r r& r r r rR t � zVersion.is_postreleasec C r� r$ )r r& r r r rS x r� zVersion.is_devreleasec C s t | j�dkr | jd S dS )Nr r ��lenr r& r r r �major| � z Version.majorc C � t | j�dkr | jd S dS )N� r r r� r& r r r �minor� r� z Version.minorc C r� )N� r� r r� r& r r r �micro� r� z Version.micro) r r r �re�compiler �VERBOSE� IGNORECASEr| r; rA rG rD rT r8 r r r r r r r r rI rK r9 rQ rR rS r� r� r� r r r r r sB r �letter�numberc C sv | r-|d u rd}| � � } | dkrd} n| dkrd} n | dv r!d} n| dv r'd } | t|�fS | s9|r9d } | t|�fS d S ) Nr �alpha�a�beta�b)rU r rW rY )�rev�rr )rh r8 )r� r� r r r r � s" r z[\._-]r c C s$ | durt dd� t�| �D ��S dS )zR Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). Nc s s( � | ]}|� � s |�� nt|�V qd S r$ )�isdigitrh r8 )rq re r r r rs � s � � �z'_parse_local_version.<locals>.<genexpr>)rl �_local_version_separatorsra )r r r r r� � s �r� r r r r r c C s� t ttt�dd� t|�����}|d u r |d u r |d ur t}n |d u r&t}n|}|d u r/t}n|}|d u r8t} n|} |d u rAt} n t dd� |D ��} | |||| | fS )Nc S s | dkS )Nr r )r� r r r �<lambda>� s z_cmpkey.<locals>.<lambda>c s s* � | ]}t |t�r |d fnt|fV qdS )r� N)r+ r8 r rp r r r rs � s � �z_cmpkey.<locals>.<genexpr>)rl �reversed�list� itertools� dropwhiler r ) r r r r r r r� r� �_post�_dev�_localr r r r� � s( � �r� )0� collectionsr� r� r> �typingr r r r r r r � _structuresr r r r �__all__� InfiniteTypesr; r8 �PrePostDevType� SubLocalType� LocalTyper5 r6 r9 �VersionComparisonMethod� namedtupler r � ValueErrorr r" r r� r� r` rb rf r= r r �bytesr r� r� r� r r r r �<module> s� $ ������ ��� .>� � � � $ � ���� �� __pycache__/_musllinux.cpython-310.pyc 0000644 00000010740 15030064307 0013654 0 ustar 00 o �7]h � @ s~ d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z m Z mZ de e dedeedf fdd �Zde e de e fd d �ZG d d � d e �Zdede e fdd�Ze�� dede e fdd��Zdede e fdd�Zedkr�ddlZe�� Z e � d�s�J d��e de � e deej �� e d d d � ee� d d e �!d!d"�d# ��D ] Z"e e"d$d � q�dS dS )%z�PEP 656 support. This module implements logic to detect if the currently running Python is linked against musl, and what musl version is used. � N)�IO�Iterator� NamedTuple�Optional�Tuple�f�fmt�return.c C s t �|| �t �|���S �N)�struct�unpack�read�calcsize)r r � r �B/usr/lib/python3/dist-packages/pip/_vendor/packaging/_musllinux.py�_read_unpacked s r c C sb | � d� zt| d�}W n tjy Y dS w |dd� td�kr$dS | � t�d�d� zdd d �|d \}}}W n tyE Y dS w tj|� }zt| |�\}}}}}}} W n tjyd Y dS w t | d �D ]C} | � ||| � z |t| |��\} } } W n tjy� Y dS w | d kr�qk| � | � t � | � | ��� d �}d |vr� dS | S dS )z�Detect musl libc location by parsing the Python executable. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html r �16BN� s ELF�HHI� )�IIIIHHH�IIIIIIII)r r r )�QQQIHHH�IIQQQQQQ)r � � )r r � � �musl)�seekr r �error�tupler �KeyError�operator� itemgetter�range�os�fsdecoder �strip)r �ident�e_fmt�p_fmt�p_idx�p_get�_�e_phoff� e_phentsize�e_phnum�i�p_type�p_offset�p_filesz� interpreterr r r �_parse_ld_musl_from_elf sN ��� � �� r7 c @ s e Zd ZU eed< eed< dS )� _MuslVersion�major�minorN)�__name__� __module__� __qualname__�int�__annotations__r r r r r8 G s r8 �outputc C sx dd� dd� | � � D �D �}t|�dk s |d d d� dkr d S t�d |d �}|s,d S tt|�d ��t|�d��d �S ) Nc S s g | ]}|r|�qS r r ��.0�nr r r � <listcomp>M s z'_parse_musl_version.<locals>.<listcomp>c s s � | ]}|� � V qd S r )r( rA r r r � <genexpr>M s � z&_parse_musl_version.<locals>.<genexpr>r r r r zVersion (\d+)\.(\d+)r )r9 r: )� splitlines�len�re�matchr8 r> �group)r@ �lines�mr r r �_parse_musl_versionL s rM � executablec C s� t �� �'}z |�t| d��}W n ty Y W d � dS w t|�}W d � n1 s.w Y |s7dS tj|gtjdd�}t |j �S )a` Detect currently-running musl runtime version. This is done by checking the specified executable's dynamic linking information, and invoking the loader to parse its output for a version string. If the loader is musl, the output would be something like:: musl libc (x86_64) Version 1.2.2 Dynamic Program Loader �rbNT)�stderr�universal_newlines) � contextlib� ExitStack� enter_context�open�OSErrorr7 � subprocess�run�PIPErM rP )rN �stackr �ld�procr r r �_get_musl_versionV s � � r] �archc c sJ � t tj�}|du r dS t|jdd�D ]}d|j� d|� d| � �V qdS )aT Generate musllinux tags compatible to the current platform. :param arch: Should be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be musllinux-compatible. :returns: An iterator of compatible musllinux tags. N���� musllinux_r. )r] �sysrN r% r: r9 )r^ �sys_muslr: r r r � platform_tagsn s � �rc �__main__zlinux-z not linuxzplat:zmusl:ztags:� )�endz[.-]r. �-r r_ z )#�__doc__rR � functoolsr# r& rH r rW ra �typingr r r r r �bytes�strr> r r7 r8 rM � lru_cacher] rc r; � sysconfig� get_platform�plat� startswith�printrN �sub�split�tr r r r �<module> s8 "1 "� __pycache__/__about__.cpython-310.pyc 0000644 00000001052 15030064307 0013357 0 ustar 00 o �7]h� � @ s0 g d �Z dZdZdZdZdZdZdZde Zd S ) )� __title__� __summary__�__uri__� __version__� __author__� __email__� __license__� __copyright__� packagingz"Core utilities for Python packagesz!https://github.com/pypa/packagingz21.3z)Donald Stufft and individual contributorszdonald@stufft.iozBSD-2-Clause or Apache-2.0z 2014-2019 %sN) �__all__r r r r r r r r � r r �A/usr/lib/python3/dist-packages/pip/_vendor/packaging/__about__.py�<module> s __pycache__/requirements.cpython-310.pyc 0000644 00000007543 15030064307 0014207 0 ustar 00 o �7]hD � @ sf d dl Z d dlZd dlZd dlmZmZmZ d dl m Z m Z mZm Z mZmZmZmZmZmZ ddlmZmZ ddlmZmZmZ G dd� de�Z eej ej �Z e d �� � Z!e d �� � Z"e d �� � Z#e d �� � Z$e d �� � Z%e d�� � Z&e d�� � Z'ed�Z(e ee(�e B Z)e e ee)� �Z*e*d�Z+e*Z,ed�d�Z-e'e- Z.e,ee%e, � Z/e!ee/� e" d�Z0eej1e j2e j3B �Z4eej1e j2e j3B �Z5e4e5A Z6e e6ee%e6 � d dd�d�Z7ee#e7 e$ e7B �Z8e8�9dd� � ee8�d�Z:e:�9dd� � ee� �d �Ze�9d d� � e&Z;e;e Z<e:ee<� Z=e.ee<� Z>e+ee0� e>e=B Z?ee? e Z@e@�Ad � G d d � d �ZBdS )!� N)�List�Optional�Set) �Combine�Literalr �ParseException�Regex�Word� ZeroOrMore�originalTextFor� stringEnd� stringStart� )� MARKER_EXPR�Marker)�LegacySpecifier� Specifier� SpecifierSetc @ s e Zd ZdZdS )�InvalidRequirementzJ An invalid requirement was found, users should refer to PEP 508. N)�__name__� __module__� __qualname__�__doc__� r r �D/usr/lib/python3/dist-packages/pip/_vendor/packaging/requirements.pyr s r �[�]�(�)�,�;�@z-_.�namez[^ ]+�url�extrasF)� joinString�adjacent� _raw_specc C s |j pdS )N� )r' ��s�l�tr r r �<lambda>@ s r- � specifierc C s |d S )Nr r r) r r r r- C s �markerc C s t | |j|j� �S )N)r �_original_start� _original_endr) r r r r- G s zx[]c @ s> e Zd ZdZdeddfdd�Zdefdd�Zdefd d �ZdS ) � Requirementz�Parse a requirement. Parse a given requirement string into its parts, such as name, specifier, URL, and extras. Raises InvalidRequirement on a badly-formed requirement string. �requirement_string�returnNc C s zt �|�}W n ty& } ztd||j|jd � �d|j� ���d }~ww |j| _|jratj � |j�}|j dkrHtj � |�|jkrGtd��n|j rT|j rT|j s\|j s\td|j� ���|j| _nd | _t|jrm|j�� ng �| _t|j�| _|jr�|j| _d S d | _d S )NzParse error at "� z": �filezInvalid URL givenz Invalid URL: )� REQUIREMENT� parseStringr r �loc�msgr" r# �urllib�parse�urlparse�scheme� urlunparse�netloc�setr$ �asListr r. r/ )�selfr3 �req�e� parsed_urlr r r �__init__d s4 ��� � �� zRequirement.__init__c C s� | j g}| jrd�t| j��}|�d|� d�� | jr#|�t| j�� | jr7|�d| j� �� | jr7|�d� | jrC|�d| j� �� d�|�S )Nr r r z@ � z; r( ) r" r$ �join�sorted�appendr. �strr# r/ )rC �parts�formatted_extrasr r r �__str__} s zRequirement.__str__c C s d| � d�S )Nz<Requirement('z')>r )rC r r r �__repr__� s zRequirement.__repr__)r r r r rL rG rO rP r r r r r2 W s r2 )C�re�string� urllib.parser; �typingr r � TOptionalr �pip._vendor.pyparsingr r �Lr r r r r r r �markersr r � specifiersr r r � ValueErrorr � ascii_letters�digits�ALPHANUM�suppress�LBRACKET�RBRACKET�LPAREN�RPAREN�COMMA� SEMICOLON�AT� PUNCTUATION�IDENTIFIER_END� IDENTIFIER�NAME�EXTRA�URI�URL� EXTRAS_LIST�EXTRAS� _regex_str�VERBOSE� IGNORECASE�VERSION_PEP440�VERSION_LEGACY� VERSION_ONE� VERSION_MANY� _VERSION_SPEC�setParseAction� VERSION_SPEC�MARKER_SEPARATOR�MARKER�VERSION_AND_MARKER�URL_AND_MARKER�NAMED_REQUIREMENTr7 r8 r2 r r r r �<module> sb 0 �� � __pycache__/utils.cpython-310.pyc 0000644 00000006723 15030064307 0012623 0 ustar 00 o �7]hh � @ s d dl Z d dlmZmZmZmZmZ ddlmZm Z ddl m Z m Z eed ee ef f Zede�ZG dd � d e�ZG d d � d e�Ze �d �Ze �d �Zdedefdd�Zdee ef defdd�Zdedeee eee f fdd�Zdedeee f fdd�ZdS )� N)� FrozenSet�NewType�Tuple�Union�cast� )�Tag� parse_tag)�InvalidVersion�Version� �NormalizedNamec @ � e Zd ZdZdS )�InvalidWheelFilenamezM An invalid wheel filename was found, users should refer to PEP 427. N��__name__� __module__� __qualname__�__doc__r r r �=/usr/lib/python3/dist-packages/pip/_vendor/packaging/utils.pyr � r c @ r )�InvalidSdistFilenamez^ An invalid sdist filename was found, users should refer to the packaging user guide. Nr r r r r r r r z[-_.]+z (\d+)(.*)�name�returnc C s t �d| ��� }tt|�S )N�-)�_canonicalize_regex�sub�lowerr r )r �valuer r r �canonicalize_name s r �versionc C s� t | t�rzt| �}W n ty | Y S w | }g }|jdkr)|�|j� d�� |�t�ddd�dd� |j D ���� |j durO|�d�d d� |j D ��� |j dur]|�d |j � �� |j durk|�d |j � �� |j dury|�d |j � �� d�|�S ) z� This is very similar to Version.__str__, but has one subtle difference with the way it handles the release segment. r �!z(\.0)+$� �.c s � � | ]}t |�V qd S �N��str��.0�xr r r � <genexpr>< � � z'canonicalize_version.<locals>.<genexpr>Nc s r$ r% r& r( r r r r+ @ r, z.postz.dev�+)� isinstancer' r r �epoch�append�rer �join�release�pre�post�dev�local)r �parsed�partsr r r �canonicalize_version& s( � & r: �filenamec C s | � d�s td| � ���| d d� } | �d�}|dvr"td| � ���| �d|d �}|d }d |v s<t�d |tj�d u rCtd | � ���t|�}t|d �}|d kry|d }t �|�}|d u ritd|� d| � d���t t t |� d ��|� d�f�}nd}t|d �} |||| fS )Nz.whlz3Invalid wheel filename (extension must be '.whl'): ���r )� � z0Invalid wheel filename (wrong number of parts): � r �__z ^[\w\d._]*$zInvalid project name: r r> zInvalid build number: z in '�'r ���)�endswithr �count�splitr1 �match�UNICODEr r �_build_tag_regexr �BuildTag�int�groupr ) r; �dashesr9 � name_partr r � build_part� build_match�build�tagsr r r �parse_wheel_filenameQ s6 � � � rR c C s� | � d�r| d td� � }n| � d�r | d td� � }ntd| � ���|�d�\}}}|s6td| � ���t|�}t|�}||fS )Nz.tar.gzz.zipz@Invalid sdist filename (extension must be '.tar.gz' or '.zip'): r zInvalid sdist filename: )rC �lenr � rpartitionr r )r; � file_stemrM �sep� version_partr r r r r �parse_sdist_filenameu s ��rX )r1 �typingr r r r r rQ r r r r r rJ r' rI r � ValueErrorr r �compiler rH r r: rR rX r r r r �<module> s$ +� � $ __pycache__/specifiers.cpython-310.pyc 0000644 00000051763 15030064307 0013623 0 ustar 00 o �7]h�u � @ s� d dl Z d dlZd dlZd dlZd dlZd dlmZmZmZm Z m Z m Z m Z m Z mZmZmZ ddlmZ ddlmZmZmZ eeef Zeeeef Zeded�Zeeegef Z G dd � d e �Z G d d � d e j d �Z G d d� de �Z!G dd� de!�Z"dedeegef dedeegef fdd�Z#G dd� de!�Z$e�%d�Z&dede e fdd�Z'dedefd d �Z(d e e d e e dee e e e f fd d!�Z)G d"d#� d#e �Z*dS )$� N) �Callable�Dict�Iterable�Iterator�List�Optional�Pattern�Set�Tuple�TypeVar�Union� )�canonicalize_version)� LegacyVersion�Version�parse�VersionTypeVar)�boundc @ s e Zd ZdZdS )�InvalidSpecifierzH An invalid specifier was found, users should refer to PEP 440. N)�__name__� __module__� __qualname__�__doc__� r r �B/usr/lib/python3/dist-packages/pip/_vendor/packaging/specifiers.pyr ! s r c @ s� e Zd Zejdefdd��Zejdefdd��Zejde de fdd��Z ej de e fd d ��Zejd e dd fd d ��Zejddede e de fdd��Zej ddee de e dee fdd��Zd S )� BaseSpecifier�returnc C � dS )z� Returns the str representation of this Specifier like object. This should be representative of the Specifier itself. Nr ��selfr r r �__str__( � zBaseSpecifier.__str__c C r )zF Returns a hash value for this Specifier like object. Nr r r r r �__hash__/ r! zBaseSpecifier.__hash__�otherc C r )zq Returns a boolean representing whether or not the two Specifier like objects are equal. Nr �r r# r r r �__eq__5 r! zBaseSpecifier.__eq__c C r )zg Returns whether or not pre-releases as a whole are allowed by this specifier. Nr r r r r � prereleases< r! zBaseSpecifier.prereleases�valueNc C r )zd Sets whether or not pre-releases as a whole are allowed by this specifier. Nr �r r' r r r r& C r! �itemr& c C r )zR Determines if the given item is contained within this specifier. Nr �r r) r& r r r �containsJ r! zBaseSpecifier.contains�iterablec C r )z� Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr )r r, r& r r r �filterP r! zBaseSpecifier.filter�N)r r r �abc�abstractmethod�strr �intr" �object�boolr% �abstractpropertyr r& �setterr+ r r r- r r r r r ' s, ����r )� metaclassc @ sl e Zd ZU i Zeeef ed< ee ed< d+dedee ddfdd �Z defd d �Z defd d �Z e deeef fdd��Zdefdd�Zdede fdd�Zdedefdd�Zdedefdd�Ze defdd ��Ze defd d ��Ze dee fd d ��Zej d!e ddfd"d ��Zd#ede fd$d%�Z d,d#edee de fd&d'�Z d,d(e e dee de e fd)d*�Z!dS )-�_IndividualSpecifier� _operators�_regex� N�specr& r c C sH | j �|�}|std|� d���|�d��� |�d��� f| _|| _d S )NzInvalid specifier: '�'�operator�version)r: �searchr �group�strip�_spec� _prereleases)r r< r& �matchr r r �__init___ s � z _IndividualSpecifier.__init__c C s8 | j d ur d| j��nd}d| jj� dt| ��|� d�S )N�, prereleases=r; �<�(�)>)rD r& � __class__r r1 �r �prer r r �__repr__l s �� z _IndividualSpecifier.__repr__c C s dj | j� S )Nz{}{})�formatrC r r r r r u s z _IndividualSpecifier.__str__c C s | j d t| j d �fS )Nr r )rC r r r r r �_canonical_specx s z$_IndividualSpecifier._canonical_specc C � t | j�S r. )�hashrP r r r r r" | � z _IndividualSpecifier.__hash__r# c C sP t |t�rz | �t|��}W n ty t Y S w t || j�s"tS | j|jkS r. )� isinstancer1 rK r �NotImplementedrP r$ r r r r% s � z_IndividualSpecifier.__eq__�opc C s t | d| j| � ��}|S )N� _compare_)�getattrr9 )r rV �operator_callabler r r � _get_operator� s �z"_IndividualSpecifier._get_operatorr? c C s t |ttf�s t|�}|S r. )rT r r r �r r? r r r �_coerce_version� s z$_IndividualSpecifier._coerce_versionc C � | j d S )Nr �rC r r r r r> � � z _IndividualSpecifier.operatorc C r] )Nr r^ r r r r r? � r_ z _IndividualSpecifier.versionc C s | j S r. �rD r r r r r& � s z _IndividualSpecifier.prereleasesr' c C � || _ d S r. r` r( r r r r& � r_ r) c C � | � |�S r. �r+ �r r) r r r � __contains__� rS z!_IndividualSpecifier.__contains__c C s> |d u r| j }| �|�}|jr|sdS | �| j�}||| j�S �NF)r& r\ � is_prereleaserZ r> r? )r r) r& �normalized_itemrY r r r r+ � s z _IndividualSpecifier.containsr, c c s� � d}g }d|d ur |ndi}|D ]#}| � |�}| j|fi |��r4|jr/|s/| js/|�|� qd}|V q|sA|rC|D ] }|V q;d S d S d S )NFr& T)r\ r+ rg r& �append)r r, r& �yielded�found_prereleases�kwr? �parsed_versionr r r r- � s* � �� ��z_IndividualSpecifier.filter�r; Nr. )"r r r r9 r r1 �__annotations__r r r4 rF rN r �propertyr rP r2 r" r3 r% �CallableOperatorrZ �UnparsedVersion� ParsedVersionr\ r> r? r& r6 re r+ r r r- r r r r r8 Z sJ ��� �����r8 c s� e Zd ZdZe�de d ejejB �Zdddddd d �Z d"d e de e dd f� fdd� Z dedefdd�Zded e de fdd�Zded e de fdd�Zded e de fdd�Zded e de fd d �Zded e de fd d �Zded e de fd d!�Z� ZS )#�LegacySpecifiera� (?P<operator>(==|!=|<=|>=|<|>)) \s* (?P<version> [^,;\s)]* # Since this is a "legacy" specifier, and the version # string can be just about anything, we match everything # except for whitespace, a semi-colon for marker support, # a closing paren since versions can be enclosed in # them, and a comma since it's a version separator. ) �^\s*�\s*$�equal� not_equal�less_than_equal�greater_than_equal� less_than� greater_than)�==�!=�<=�>=rH �>r; Nr< r& r c s t � �||� t�dt� d S )NzZCreating a LegacyVersion has been deprecated and will be removed in the next major release)�superrF �warnings�warn�DeprecationWarning)r r< r& �rK r r rF � s �zLegacySpecifier.__init__r? c C s t |t�s tt|��}|S r. )rT r r1 r[ r r r r\ s z LegacySpecifier._coerce_version� prospectivec C s || � |�kS r. �r\ �r r� r< r r r �_compare_equal � z LegacySpecifier._compare_equalc C s || � |�kS r. r� r� r r r �_compare_not_equal r� z"LegacySpecifier._compare_not_equalc C s || � |�kS r. r� r� r r r �_compare_less_than_equal r� z(LegacySpecifier._compare_less_than_equalc C s || � |�kS r. r� r� r r r �_compare_greater_than_equal s z+LegacySpecifier._compare_greater_than_equalc C s || � |�k S r. r� r� r r r �_compare_less_than r� z"LegacySpecifier._compare_less_thanc C s || � |�kS r. r� r� r r r �_compare_greater_than r� z%LegacySpecifier._compare_greater_thanrn )r r r � _regex_str�re�compile�VERBOSE� IGNORECASEr: r9 r1 r r4 rF rr r r\ r� r� r� r� r� r� � __classcell__r r r� r rt � s0 � �� � rt �fn� Specifierr c s, t �� �dddtdtdtf� fdd� �}|S )Nr r� r� r< r c s t |t�sdS � | ||�S rf )rT r r� �r� r r �wrapped" s z)_require_version_compare.<locals>.wrapped)� functools�wrapsrs r1 r4 )r� r� r r� r �_require_version_compare s r� c @ s8 e Zd ZdZe�de d ejejB �Zdddddd d d d �Z e d e de de fdd��Ze d e de de fdd��Ze d e de de fdd��Ze d e de de fdd��Ze d e de de fdd��Ze d e de de fdd ��Ze d e de de fd d ��Zd ede de fd d �Zede fd!d"��Zejd#e dd$fd%d"��Zd$S )&r� a (?P<operator>(~=|==|!=|<=|>=|<|>|===)) (?P<version> (?: # The identity operators allow for an escape hatch that will # do an exact string match of the version you wish to install. # This will not be parsed by PEP 440 and we cannot determine # any semantic meaning from it. This operator is discouraged # but included entirely as an escape hatch. (?<====) # Only match for the identity operator \s* [^\s]* # We just match everything, except for whitespace # since we are only testing for strict identity. ) | (?: # The (non)equality operators allow for wild card and local # versions to be specified so we have to define these two # operators separately to enable that. (?<===|!=) # Only match for equals and not equals \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? # You cannot use a wild card and a dev or local version # together so group them with a | and make them optional. (?: (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local | \.\* # Wild card syntax of .* )? ) | (?: # The compatible operator requires at least two digits in the # release segment. (?<=~=) # Only match for the compatible operator \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) | (?: # All other operators only allow a sub set of what the # (non)equality operators do. Specifically they do not allow # local versions to be specified nor do they allow the prefix # matching wild cards. (?<!==|!=|~=) # We have special cases for these # operators so we want to make sure they # don't match here. \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) ) ru rv � compatiblerw rx ry rz r{ r| � arbitrary)�~=r} r~ r r� rH r� �===r� r< r c C sJ d� tt�tt|���d d� �}|d7 }| �d�||�o$| �d�||�S )N�.����.*r� r} )�join�list� itertools� takewhile�_is_not_suffix�_version_splitrZ )r r� r< �prefixr r r �_compare_compatible� s ��z Specifier._compare_compatiblec C sv |� d�r+t|j�}t|d d� �}tt|��}|d t|�� }t||�\}}||kS t|�}|js7t|j�}||kS )Nr� ���)�endswithr �publicr� r1 �len� _pad_version�local) r r� r< � split_spec�split_prospective�shortened_prospective� padded_spec�padded_prospective� spec_versionr r r r� � s � zSpecifier._compare_equalc C s | � ||� S r. )r� r� r r r r� � s z Specifier._compare_not_equalc C s t |j�t |�kS r. �r r� r� r r r r� � s z"Specifier._compare_less_than_equalc C s t |j�t |�kS r. r� r� r r r r� � s z%Specifier._compare_greater_than_equal�spec_strc C s< t |�}||k s dS |js |jr t |j�t |j�kr dS dS �NFT)r rg � base_version�r r� r� r< r r r r� � s z Specifier._compare_less_thanc C s^ t |�}||ks dS |js |jr t |j�t |j�kr dS |jd ur-t |j�t |j�kr-dS dS r� )r �is_postreleaser� r� r� r r r r� s z Specifier._compare_greater_thanc C s t |��� t |��� kS r. )r1 �lowerr� r r r �_compare_arbitrary% s z Specifier._compare_arbitraryc C sR | j d ur| j S | j\}}|dv r'|dkr |�d�r |d d� }t|�jr'dS dS )N)r} r� r r� r� r} r� r� TF)rD rC r� r rg )r r> r? r r r r& ( s zSpecifier.prereleasesr' Nc C ra r. r` r( r r r r& A r_ )r r r r� r� r� r� r� r: r9 r� rs r1 r4 r� r� r� r� r� r� r� r r� rp r& r6 r r r r r� + sJ ]� '�� � z ^([0-9]+)((?:a|b|c|rc)[0-9]+)$r? c C s@ g }| � d�D ]}t�|�}|r|�|�� � q|�|� q|S )Nr� )�split� _prefix_regexr@ �extend�groupsri )r? �resultr) rE r r r r� I s r� �segmentc s t � fdd�dD �� S )Nc 3 s � | ]}� � |�V qd S r. )� startswith)�.0r� �r� r r � <genexpr>U s � �z!_is_not_suffix.<locals>.<genexpr>)�dev�a�b�rc�post)�anyr� r r� r r� T s �r� �left�rightc C s� g g }}|� tt�dd� | ��� |� tt�dd� |��� |� | t|d �d � � |� |t|d �d � � |�ddgtdt|d �t|d � � � |�ddgtdt|d �t|d � � � ttj|� �ttj|� �fS )Nc S � | � � S r. ��isdigit��xr r r �<lambda>^ � z _pad_version.<locals>.<lambda>c S r� r. r� r� r r r r� _ r� r r �0)ri r� r� r� r� �insert�max�chain)r� r� � left_split� right_splitr r r r� Z s ,, r� c @ s$ e Zd Z d#dedee ddfdd�Zdefdd �Zdefd d �Zde fd d �Z de d ef dd fdd�Z de defdd�Zde fdd�Zdee fdd�Zedee fdd��Zejdeddfdd��Zdedefd d �Z d$dedee defd d �Z d$d ee dee dee fd!d"�ZdS )%� SpecifierSetr; N� specifiersr& r c C sj dd� |� d�D �}t� }|D ]}z |�t|�� W q ty* |�t|�� Y qw t|�| _|| _d S )Nc S s g | ] }|� � r|� � �qS r )rB �r� �sr r r � <listcomp>s s z)SpecifierSet.__init__.<locals>.<listcomp>�,) r� �set�addr� r rt � frozenset�_specsrD )r r� r& �split_specifiers�parsed� specifierr r r rF m s � zSpecifierSet.__init__c C s. | j d ur d| j��nd}dt| ��|� d�S )NrG r; z<SpecifierSet(rJ )rD r& r1 rL r r r rN � s ��zSpecifierSet.__repr__c C s d� tdd� | jD ���S )Nr� c s s � | ]}t |�V qd S r. )r1 r� r r r r� � s � z'SpecifierSet.__str__.<locals>.<genexpr>)r� �sortedr� r r r r r � s zSpecifierSet.__str__c C rQ r. )rR r� r r r r r" � rS zSpecifierSet.__hash__r# c C s� t |t�r t|�}nt |t�stS t� }t| j|jB �|_| jd u r-|jd ur-|j|_|S | jd ur=|jd u r=| j|_|S | j|jkrI| j|_|S td��)NzFCannot combine SpecifierSets with True and False prerelease overrides.)rT r1 r� rU r� r� rD � ValueError)r r# r� r r r �__and__� s$ � ���zSpecifierSet.__and__c C s6 t |ttf�rtt|��}nt |t�stS | j|jkS r. )rT r1 r8 r� rU r� r$ r r r r% � s zSpecifierSet.__eq__c C rQ r. )r� r� r r r r �__len__� rS zSpecifierSet.__len__c C rQ r. )�iterr� r r r r �__iter__� rS zSpecifierSet.__iter__c C s. | j d ur| j S | js d S tdd� | jD ��S )Nc s s � | ]}|j V qd S r. �r& r� r r r r� � s � z+SpecifierSet.prereleases.<locals>.<genexpr>)rD r� r� r r r r r& � s zSpecifierSet.prereleasesr' c C ra r. r` r( r r r r& � r_ r) c C rb r. rc rd r r r re � rS zSpecifierSet.__contains__c sL t � ttf�s t� �� �d u r| j��s� jrdS t� �fdd�| jD ��S )NFc 3 s � | ] }|j � �d �V qdS )r� Nrc r� �r) r& r r r� � s � z(SpecifierSet.contains.<locals>.<genexpr>)rT r r r r& rg �allr� r* r r� r r+ � s zSpecifierSet.containsr, c C s� |d u r| j }| jr| jD ] }|j|t|�d�}q |S g }g }|D ](}t|ttf�s/t|�}n|}t|t�r7q!|jrD|sD|sC|� |� q!|� |� q!|sT|rT|d u rT|S |S )Nr� ) r& r� r- r4 rT r r r rg ri )r r, r& r< �filteredrk r) rm r r r r- � s, � zSpecifierSet.filterrn r. ) r r r r1 r r4 rF rN r r2 r" r r� r3 r% r� r r8 r� rp r& r6 rr re r+ r r r- r r r r r� l sJ ��� � ��� � ����r� )+r/ r� r� r� r� �typingr r r r r r r r r r r �utilsr r? r r r rs r1 rr r r4 rq r� r �ABCMetar r8 rt r� r� r� r� r� r� r� r� r r r r �<module> s< 4 3 <� � . __pycache__/_structures.cpython-310.pyc 0000644 00000005155 15030064307 0014043 0 ustar 00 o �7]h� � @ s, G d d� d�Z e � ZG dd� d�Ze� ZdS )c @ s� e Zd Zdefdd�Zdefdd�Zdedefdd�Z dedefd d �Z dedefd d �Z dedefd d�Z dedefdd�Z deddfdd�ZdS )� InfinityType�returnc C � dS )N�Infinity� ��selfr r �C/usr/lib/python3/dist-packages/pip/_vendor/packaging/_structures.py�__repr__ � zInfinityType.__repr__c C � t t| ��S �N��hash�reprr r r r �__hash__ � zInfinityType.__hash__�otherc C r �NFr �r r r r r �__lt__ r zInfinityType.__lt__c C r r r r r r r �__le__ r zInfinityType.__le__c C � t || j�S r �� isinstance� __class__r r r r �__eq__ r zInfinityType.__eq__c C r �NTr r r r r �__gt__ r zInfinityType.__gt__c C r r r r r r r �__ge__ r zInfinityType.__ge__r �NegativeInfinityTypec C � t S r )�NegativeInfinityr r r r �__neg__ r zInfinityType.__neg__N)�__name__� __module__� __qualname__�strr �intr �object�boolr r r r r r" r r r r r � r c @ s� e Zd Zdefdd�Zdefdd�Zdedefdd�Z dedefd d �Z dedefd d �Z dedefd d�Z dedefdd�Z dedefdd�ZdS )r r c C r )Nz -Infinityr r r r r r $ r z NegativeInfinityType.__repr__c C r r r r r r r r ' r z NegativeInfinityType.__hash__r c C r r r r r r r r * r zNegativeInfinityType.__lt__c C r r r r r r r r - r zNegativeInfinityType.__le__c C r r r r r r r r 0 r zNegativeInfinityType.__eq__c C r r r r r r r r 3 r zNegativeInfinityType.__gt__c C r r r r r r r r 6 r zNegativeInfinityType.__ge__r c C r r )r r r r r r" 9 r z NegativeInfinityType.__neg__N)r# r$ r% r& r r' r r( r) r r r r r r r" r r r r r # r* r N)r r r r! r r r r �<module> s py.typed 0000644 00000000000 15030064307 0006227 0 ustar 00 _structures.py 0000644 00000002627 15030064307 0007505 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. class InfinityType: def __repr__(self) -> str: return "Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return False def __le__(self, other: object) -> bool: return False def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return True def __ge__(self, other: object) -> bool: return True def __neg__(self: object) -> "NegativeInfinityType": return NegativeInfinity Infinity = InfinityType() class NegativeInfinityType: def __repr__(self) -> str: return "-Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return True def __le__(self, other: object) -> bool: return True def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return False def __ge__(self, other: object) -> bool: return False def __neg__(self: object) -> InfinityType: return Infinity NegativeInfinity = NegativeInfinityType() version.py 0000644 00000034511 15030064307 0006605 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import collections import itertools import re import warnings from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType __all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"] InfiniteTypes = Union[InfinityType, NegativeInfinityType] PrePostDevType = Union[InfiniteTypes, Tuple[str, int]] SubLocalType = Union[InfiniteTypes, int, str] LocalType = Union[ NegativeInfinityType, Tuple[ Union[ SubLocalType, Tuple[SubLocalType, str], Tuple[NegativeInfinityType, SubLocalType], ], ..., ], ] CmpKey = Tuple[ int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType ] LegacyCmpKey = Tuple[int, Tuple[str, ...]] VersionComparisonMethod = Callable[ [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool ] _Version = collections.namedtuple( "_Version", ["epoch", "release", "dev", "pre", "post", "local"] ) def parse(version: str) -> Union["LegacyVersion", "Version"]: """ Parse the given version string and return either a :class:`Version` object or a :class:`LegacyVersion` object depending on if the given version is a valid PEP 440 version or a legacy version. """ try: return Version(version) except InvalidVersion: return LegacyVersion(version) class InvalidVersion(ValueError): """ An invalid version was found, users should refer to PEP 440. """ class _BaseVersion: _key: Union[CmpKey, LegacyCmpKey] def __hash__(self) -> int: return hash(self._key) # Please keep the duplicated `isinstance` check # in the six comparisons hereunder # unless you find a way to avoid adding overhead function calls. def __lt__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key < other._key def __le__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key <= other._key def __eq__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key == other._key def __ge__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key >= other._key def __gt__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key > other._key def __ne__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key != other._key class LegacyVersion(_BaseVersion): def __init__(self, version: str) -> None: self._version = str(version) self._key = _legacy_cmpkey(self._version) warnings.warn( "Creating a LegacyVersion has been deprecated and will be " "removed in the next major release", DeprecationWarning, ) def __str__(self) -> str: return self._version def __repr__(self) -> str: return f"<LegacyVersion('{self}')>" @property def public(self) -> str: return self._version @property def base_version(self) -> str: return self._version @property def epoch(self) -> int: return -1 @property def release(self) -> None: return None @property def pre(self) -> None: return None @property def post(self) -> None: return None @property def dev(self) -> None: return None @property def local(self) -> None: return None @property def is_prerelease(self) -> bool: return False @property def is_postrelease(self) -> bool: return False @property def is_devrelease(self) -> bool: return False _legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE) _legacy_version_replacement_map = { "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@", } def _parse_version_parts(s: str) -> Iterator[str]: for part in _legacy_version_component_re.split(s): part = _legacy_version_replacement_map.get(part, part) if not part or part == ".": continue if part[:1] in "0123456789": # pad for numeric comparison yield part.zfill(8) else: yield "*" + part # ensure that alpha/beta/candidate are before final yield "*final" def _legacy_cmpkey(version: str) -> LegacyCmpKey: # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch # greater than or equal to 0. This will effectively put the LegacyVersion, # which uses the defacto standard originally implemented by setuptools, # as before all PEP 440 versions. epoch = -1 # This scheme is taken from pkg_resources.parse_version setuptools prior to # it's adoption of the packaging library. parts: List[str] = [] for part in _parse_version_parts(version.lower()): if part.startswith("*"): # remove "-" before a prerelease tag if part < "*final": while parts and parts[-1] == "*final-": parts.pop() # remove trailing zeros from each series of numeric parts while parts and parts[-1] == "00000000": parts.pop() parts.append(part) return epoch, tuple(parts) # Deliberately not anchored to the start and end of the string, to make it # easier for 3rd party code to reuse VERSION_PATTERN = r""" v? (?: (?:(?P<epoch>[0-9]+)!)? # epoch (?P<release>[0-9]+(?:\.[0-9]+)*) # release segment (?P<pre> # pre-release [-_\.]? (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview)) [-_\.]? (?P<pre_n>[0-9]+)? )? (?P<post> # post release (?:-(?P<post_n1>[0-9]+)) | (?: [-_\.]? (?P<post_l>post|rev|r) [-_\.]? (?P<post_n2>[0-9]+)? ) )? (?P<dev> # dev release [-_\.]? (?P<dev_l>dev) [-_\.]? (?P<dev_n>[0-9]+)? )? ) (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version """ class Version(_BaseVersion): _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE) def __init__(self, version: str) -> None: # Validate the version and parse it into pieces match = self._regex.search(version) if not match: raise InvalidVersion(f"Invalid version: '{version}'") # Store the parsed out pieces of the version self._version = _Version( epoch=int(match.group("epoch")) if match.group("epoch") else 0, release=tuple(int(i) for i in match.group("release").split(".")), pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")), post=_parse_letter_version( match.group("post_l"), match.group("post_n1") or match.group("post_n2") ), dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")), local=_parse_local_version(match.group("local")), ) # Generate a key which will be used for sorting self._key = _cmpkey( self._version.epoch, self._version.release, self._version.pre, self._version.post, self._version.dev, self._version.local, ) def __repr__(self) -> str: return f"<Version('{self}')>" def __str__(self) -> str: parts = [] # Epoch if self.epoch != 0: parts.append(f"{self.epoch}!") # Release segment parts.append(".".join(str(x) for x in self.release)) # Pre-release if self.pre is not None: parts.append("".join(str(x) for x in self.pre)) # Post-release if self.post is not None: parts.append(f".post{self.post}") # Development release if self.dev is not None: parts.append(f".dev{self.dev}") # Local version segment if self.local is not None: parts.append(f"+{self.local}") return "".join(parts) @property def epoch(self) -> int: _epoch: int = self._version.epoch return _epoch @property def release(self) -> Tuple[int, ...]: _release: Tuple[int, ...] = self._version.release return _release @property def pre(self) -> Optional[Tuple[str, int]]: _pre: Optional[Tuple[str, int]] = self._version.pre return _pre @property def post(self) -> Optional[int]: return self._version.post[1] if self._version.post else None @property def dev(self) -> Optional[int]: return self._version.dev[1] if self._version.dev else None @property def local(self) -> Optional[str]: if self._version.local: return ".".join(str(x) for x in self._version.local) else: return None @property def public(self) -> str: return str(self).split("+", 1)[0] @property def base_version(self) -> str: parts = [] # Epoch if self.epoch != 0: parts.append(f"{self.epoch}!") # Release segment parts.append(".".join(str(x) for x in self.release)) return "".join(parts) @property def is_prerelease(self) -> bool: return self.dev is not None or self.pre is not None @property def is_postrelease(self) -> bool: return self.post is not None @property def is_devrelease(self) -> bool: return self.dev is not None @property def major(self) -> int: return self.release[0] if len(self.release) >= 1 else 0 @property def minor(self) -> int: return self.release[1] if len(self.release) >= 2 else 0 @property def micro(self) -> int: return self.release[2] if len(self.release) >= 3 else 0 def _parse_letter_version( letter: str, number: Union[str, bytes, SupportsInt] ) -> Optional[Tuple[str, int]]: if letter: # We consider there to be an implicit 0 in a pre-release if there is # not a numeral associated with it. if number is None: number = 0 # We normalize any letters to their lower case form letter = letter.lower() # We consider some words to be alternate spellings of other words and # in those cases we want to normalize the spellings to our preferred # spelling. if letter == "alpha": letter = "a" elif letter == "beta": letter = "b" elif letter in ["c", "pre", "preview"]: letter = "rc" elif letter in ["rev", "r"]: letter = "post" return letter, int(number) if not letter and number: # We assume if we are given a number, but we are not given a letter # then this is using the implicit post release syntax (e.g. 1.0-1) letter = "post" return letter, int(number) return None _local_version_separators = re.compile(r"[\._-]") def _parse_local_version(local: str) -> Optional[LocalType]: """ Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). """ if local is not None: return tuple( part.lower() if not part.isdigit() else int(part) for part in _local_version_separators.split(local) ) return None def _cmpkey( epoch: int, release: Tuple[int, ...], pre: Optional[Tuple[str, int]], post: Optional[Tuple[str, int]], dev: Optional[Tuple[str, int]], local: Optional[Tuple[SubLocalType]], ) -> CmpKey: # When we compare a release version, we want to compare it with all of the # trailing zeros removed. So we'll use a reverse the list, drop all the now # leading zeros until we come to something non zero, then take the rest # re-reverse it back into the correct order and make it a tuple and use # that for our sorting key. _release = tuple( reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release)))) ) # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0. # We'll do this by abusing the pre segment, but we _only_ want to do this # if there is not a pre or a post segment. If we have one of those then # the normal sorting rules will handle this case correctly. if pre is None and post is None and dev is not None: _pre: PrePostDevType = NegativeInfinity # Versions without a pre-release (except as noted above) should sort after # those with one. elif pre is None: _pre = Infinity else: _pre = pre # Versions without a post segment should sort before those with one. if post is None: _post: PrePostDevType = NegativeInfinity else: _post = post # Versions without a development segment should sort after those with one. if dev is None: _dev: PrePostDevType = Infinity else: _dev = dev if local is None: # Versions without a local segment should sort before those with one. _local: LocalType = NegativeInfinity else: # Versions with a local segment need that segment parsed to implement # the sorting rules in PEP440. # - Alpha numeric segments sort before numeric segments # - Alpha numeric segments sort lexicographically # - Numeric segments sort numerically # - Shorter versions sort before longer versions when the prefixes # match exactly _local = tuple( (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local ) return epoch, _release, _pre, _post, _dev, _local _musllinux.py 0000644 00000010432 15030064307 0007313 0 ustar 00 """PEP 656 support. This module implements logic to detect if the currently running Python is linked against musl, and what musl version is used. """ import contextlib import functools import operator import os import re import struct import subprocess import sys from typing import IO, Iterator, NamedTuple, Optional, Tuple def _read_unpacked(f: IO[bytes], fmt: str) -> Tuple[int, ...]: return struct.unpack(fmt, f.read(struct.calcsize(fmt))) def _parse_ld_musl_from_elf(f: IO[bytes]) -> Optional[str]: """Detect musl libc location by parsing the Python executable. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html """ f.seek(0) try: ident = _read_unpacked(f, "16B") except struct.error: return None if ident[:4] != tuple(b"\x7fELF"): # Invalid magic, not ELF. return None f.seek(struct.calcsize("HHI"), 1) # Skip file type, machine, and version. try: # e_fmt: Format for program header. # p_fmt: Format for section header. # p_idx: Indexes to find p_type, p_offset, and p_filesz. e_fmt, p_fmt, p_idx = { 1: ("IIIIHHH", "IIIIIIII", (0, 1, 4)), # 32-bit. 2: ("QQQIHHH", "IIQQQQQQ", (0, 2, 5)), # 64-bit. }[ident[4]] except KeyError: return None else: p_get = operator.itemgetter(*p_idx) # Find the interpreter section and return its content. try: _, e_phoff, _, _, _, e_phentsize, e_phnum = _read_unpacked(f, e_fmt) except struct.error: return None for i in range(e_phnum + 1): f.seek(e_phoff + e_phentsize * i) try: p_type, p_offset, p_filesz = p_get(_read_unpacked(f, p_fmt)) except struct.error: return None if p_type != 3: # Not PT_INTERP. continue f.seek(p_offset) interpreter = os.fsdecode(f.read(p_filesz)).strip("\0") if "musl" not in interpreter: return None return interpreter return None class _MuslVersion(NamedTuple): major: int minor: int def _parse_musl_version(output: str) -> Optional[_MuslVersion]: lines = [n for n in (n.strip() for n in output.splitlines()) if n] if len(lines) < 2 or lines[0][:4] != "musl": return None m = re.match(r"Version (\d+)\.(\d+)", lines[1]) if not m: return None return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2))) @functools.lru_cache() def _get_musl_version(executable: str) -> Optional[_MuslVersion]: """Detect currently-running musl runtime version. This is done by checking the specified executable's dynamic linking information, and invoking the loader to parse its output for a version string. If the loader is musl, the output would be something like:: musl libc (x86_64) Version 1.2.2 Dynamic Program Loader """ with contextlib.ExitStack() as stack: try: f = stack.enter_context(open(executable, "rb")) except OSError: return None ld = _parse_ld_musl_from_elf(f) if not ld: return None proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True) return _parse_musl_version(proc.stderr) def platform_tags(arch: str) -> Iterator[str]: """Generate musllinux tags compatible to the current platform. :param arch: Should be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be musllinux-compatible. :returns: An iterator of compatible musllinux tags. """ sys_musl = _get_musl_version(sys.executable) if sys_musl is None: # Python not dynamically linked against musl. return for minor in range(sys_musl.minor, -1, -1): yield f"musllinux_{sys_musl.major}_{minor}_{arch}" if __name__ == "__main__": # pragma: no cover import sysconfig plat = sysconfig.get_platform() assert plat.startswith("linux-"), "not linux" print("plat:", plat) print("musl:", _get_musl_version(sys.executable)) print("tags:", end=" ") for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])): print(t, end="\n ") __about__.py 0000644 00000001225 15030064307 0007022 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. __all__ = [ "__title__", "__summary__", "__uri__", "__version__", "__author__", "__email__", "__license__", "__copyright__", ] __title__ = "packaging" __summary__ = "Core utilities for Python packages" __uri__ = "https://github.com/pypa/packaging" __version__ = "21.3" __author__ = "Donald Stufft and individual contributors" __email__ = "donald@stufft.io" __license__ = "BSD-2-Clause or Apache-2.0" __copyright__ = "2014-2019 %s" % __author__ specifiers.py 0000644 00000072636 15030064307 0007266 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc import functools import itertools import re import warnings from typing import ( Callable, Dict, Iterable, Iterator, List, Optional, Pattern, Set, Tuple, TypeVar, Union, ) from .utils import canonicalize_version from .version import LegacyVersion, Version, parse ParsedVersion = Union[Version, LegacyVersion] UnparsedVersion = Union[Version, LegacyVersion, str] VersionTypeVar = TypeVar("VersionTypeVar", bound=UnparsedVersion) CallableOperator = Callable[[ParsedVersion, str], bool] class InvalidSpecifier(ValueError): """ An invalid specifier was found, users should refer to PEP 440. """ class BaseSpecifier(metaclass=abc.ABCMeta): @abc.abstractmethod def __str__(self) -> str: """ Returns the str representation of this Specifier like object. This should be representative of the Specifier itself. """ @abc.abstractmethod def __hash__(self) -> int: """ Returns a hash value for this Specifier like object. """ @abc.abstractmethod def __eq__(self, other: object) -> bool: """ Returns a boolean representing whether or not the two Specifier like objects are equal. """ @abc.abstractproperty def prereleases(self) -> Optional[bool]: """ Returns whether or not pre-releases as a whole are allowed by this specifier. """ @prereleases.setter def prereleases(self, value: bool) -> None: """ Sets whether or not pre-releases as a whole are allowed by this specifier. """ @abc.abstractmethod def contains(self, item: str, prereleases: Optional[bool] = None) -> bool: """ Determines if the given item is contained within this specifier. """ @abc.abstractmethod def filter( self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None ) -> Iterable[VersionTypeVar]: """ Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. """ class _IndividualSpecifier(BaseSpecifier): _operators: Dict[str, str] = {} _regex: Pattern[str] def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None: match = self._regex.search(spec) if not match: raise InvalidSpecifier(f"Invalid specifier: '{spec}'") self._spec: Tuple[str, str] = ( match.group("operator").strip(), match.group("version").strip(), ) # Store whether or not this Specifier should accept prereleases self._prereleases = prereleases def __repr__(self) -> str: pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return f"<{self.__class__.__name__}({str(self)!r}{pre})>" def __str__(self) -> str: return "{}{}".format(*self._spec) @property def _canonical_spec(self) -> Tuple[str, str]: return self._spec[0], canonicalize_version(self._spec[1]) def __hash__(self) -> int: return hash(self._canonical_spec) def __eq__(self, other: object) -> bool: if isinstance(other, str): try: other = self.__class__(str(other)) except InvalidSpecifier: return NotImplemented elif not isinstance(other, self.__class__): return NotImplemented return self._canonical_spec == other._canonical_spec def _get_operator(self, op: str) -> CallableOperator: operator_callable: CallableOperator = getattr( self, f"_compare_{self._operators[op]}" ) return operator_callable def _coerce_version(self, version: UnparsedVersion) -> ParsedVersion: if not isinstance(version, (LegacyVersion, Version)): version = parse(version) return version @property def operator(self) -> str: return self._spec[0] @property def version(self) -> str: return self._spec[1] @property def prereleases(self) -> Optional[bool]: return self._prereleases @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value def __contains__(self, item: str) -> bool: return self.contains(item) def contains( self, item: UnparsedVersion, prereleases: Optional[bool] = None ) -> bool: # Determine if prereleases are to be allowed or not. if prereleases is None: prereleases = self.prereleases # Normalize item to a Version or LegacyVersion, this allows us to have # a shortcut for ``"2.0" in Specifier(">=2") normalized_item = self._coerce_version(item) # Determine if we should be supporting prereleases in this specifier # or not, if we do not support prereleases than we can short circuit # logic if this version is a prereleases. if normalized_item.is_prerelease and not prereleases: return False # Actually do the comparison to determine if this item is contained # within this Specifier or not. operator_callable: CallableOperator = self._get_operator(self.operator) return operator_callable(normalized_item, self.version) def filter( self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None ) -> Iterable[VersionTypeVar]: yielded = False found_prereleases = [] kw = {"prereleases": prereleases if prereleases is not None else True} # Attempt to iterate over all the values in the iterable and if any of # them match, yield them. for version in iterable: parsed_version = self._coerce_version(version) if self.contains(parsed_version, **kw): # If our version is a prerelease, and we were not set to allow # prereleases, then we'll store it for later in case nothing # else matches this specifier. if parsed_version.is_prerelease and not ( prereleases or self.prereleases ): found_prereleases.append(version) # Either this is not a prerelease, or we should have been # accepting prereleases from the beginning. else: yielded = True yield version # Now that we've iterated over everything, determine if we've yielded # any values, and if we have not and we have any prereleases stored up # then we will go ahead and yield the prereleases. if not yielded and found_prereleases: for version in found_prereleases: yield version class LegacySpecifier(_IndividualSpecifier): _regex_str = r""" (?P<operator>(==|!=|<=|>=|<|>)) \s* (?P<version> [^,;\s)]* # Since this is a "legacy" specifier, and the version # string can be just about anything, we match everything # except for whitespace, a semi-colon for marker support, # a closing paren since versions can be enclosed in # them, and a comma since it's a version separator. ) """ _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE) _operators = { "==": "equal", "!=": "not_equal", "<=": "less_than_equal", ">=": "greater_than_equal", "<": "less_than", ">": "greater_than", } def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None: super().__init__(spec, prereleases) warnings.warn( "Creating a LegacyVersion has been deprecated and will be " "removed in the next major release", DeprecationWarning, ) def _coerce_version(self, version: UnparsedVersion) -> LegacyVersion: if not isinstance(version, LegacyVersion): version = LegacyVersion(str(version)) return version def _compare_equal(self, prospective: LegacyVersion, spec: str) -> bool: return prospective == self._coerce_version(spec) def _compare_not_equal(self, prospective: LegacyVersion, spec: str) -> bool: return prospective != self._coerce_version(spec) def _compare_less_than_equal(self, prospective: LegacyVersion, spec: str) -> bool: return prospective <= self._coerce_version(spec) def _compare_greater_than_equal( self, prospective: LegacyVersion, spec: str ) -> bool: return prospective >= self._coerce_version(spec) def _compare_less_than(self, prospective: LegacyVersion, spec: str) -> bool: return prospective < self._coerce_version(spec) def _compare_greater_than(self, prospective: LegacyVersion, spec: str) -> bool: return prospective > self._coerce_version(spec) def _require_version_compare( fn: Callable[["Specifier", ParsedVersion, str], bool] ) -> Callable[["Specifier", ParsedVersion, str], bool]: @functools.wraps(fn) def wrapped(self: "Specifier", prospective: ParsedVersion, spec: str) -> bool: if not isinstance(prospective, Version): return False return fn(self, prospective, spec) return wrapped class Specifier(_IndividualSpecifier): _regex_str = r""" (?P<operator>(~=|==|!=|<=|>=|<|>|===)) (?P<version> (?: # The identity operators allow for an escape hatch that will # do an exact string match of the version you wish to install. # This will not be parsed by PEP 440 and we cannot determine # any semantic meaning from it. This operator is discouraged # but included entirely as an escape hatch. (?<====) # Only match for the identity operator \s* [^\s]* # We just match everything, except for whitespace # since we are only testing for strict identity. ) | (?: # The (non)equality operators allow for wild card and local # versions to be specified so we have to define these two # operators separately to enable that. (?<===|!=) # Only match for equals and not equals \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? # You cannot use a wild card and a dev or local version # together so group them with a | and make them optional. (?: (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local | \.\* # Wild card syntax of .* )? ) | (?: # The compatible operator requires at least two digits in the # release segment. (?<=~=) # Only match for the compatible operator \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) | (?: # All other operators only allow a sub set of what the # (non)equality operators do. Specifically they do not allow # local versions to be specified nor do they allow the prefix # matching wild cards. (?<!==|!=|~=) # We have special cases for these # operators so we want to make sure they # don't match here. \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) ) """ _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE) _operators = { "~=": "compatible", "==": "equal", "!=": "not_equal", "<=": "less_than_equal", ">=": "greater_than_equal", "<": "less_than", ">": "greater_than", "===": "arbitrary", } @_require_version_compare def _compare_compatible(self, prospective: ParsedVersion, spec: str) -> bool: # Compatible releases have an equivalent combination of >= and ==. That # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to # implement this in terms of the other specifiers instead of # implementing it ourselves. The only thing we need to do is construct # the other specifiers. # We want everything but the last item in the version, but we want to # ignore suffix segments. prefix = ".".join( list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1] ) # Add the prefix notation to the end of our string prefix += ".*" return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( prospective, prefix ) @_require_version_compare def _compare_equal(self, prospective: ParsedVersion, spec: str) -> bool: # We need special logic to handle prefix matching if spec.endswith(".*"): # In the case of prefix matching we want to ignore local segment. prospective = Version(prospective.public) # Split the spec out by dots, and pretend that there is an implicit # dot in between a release segment and a pre-release segment. split_spec = _version_split(spec[:-2]) # Remove the trailing .* # Split the prospective version out by dots, and pretend that there # is an implicit dot in between a release segment and a pre-release # segment. split_prospective = _version_split(str(prospective)) # Shorten the prospective version to be the same length as the spec # so that we can determine if the specifier is a prefix of the # prospective version or not. shortened_prospective = split_prospective[: len(split_spec)] # Pad out our two sides with zeros so that they both equal the same # length. padded_spec, padded_prospective = _pad_version( split_spec, shortened_prospective ) return padded_prospective == padded_spec else: # Convert our spec string into a Version spec_version = Version(spec) # If the specifier does not have a local segment, then we want to # act as if the prospective version also does not have a local # segment. if not spec_version.local: prospective = Version(prospective.public) return prospective == spec_version @_require_version_compare def _compare_not_equal(self, prospective: ParsedVersion, spec: str) -> bool: return not self._compare_equal(prospective, spec) @_require_version_compare def _compare_less_than_equal(self, prospective: ParsedVersion, spec: str) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) <= Version(spec) @_require_version_compare def _compare_greater_than_equal( self, prospective: ParsedVersion, spec: str ) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) >= Version(spec) @_require_version_compare def _compare_less_than(self, prospective: ParsedVersion, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is less than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective < spec: return False # This special case is here so that, unless the specifier itself # includes is a pre-release version, that we do not accept pre-release # versions for the version mentioned in the specifier (e.g. <3.1 should # not match 3.1.dev0, but should match 3.0.dev0). if not spec.is_prerelease and prospective.is_prerelease: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # less than the spec version *and* it's not a pre-release of the same # version in the spec. return True @_require_version_compare def _compare_greater_than(self, prospective: ParsedVersion, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is greater than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective > spec: return False # This special case is here so that, unless the specifier itself # includes is a post-release version, that we do not accept # post-release versions for the version mentioned in the specifier # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). if not spec.is_postrelease and prospective.is_postrelease: if Version(prospective.base_version) == Version(spec.base_version): return False # Ensure that we do not allow a local version of the version mentioned # in the specifier, which is technically greater than, to match. if prospective.local is not None: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # greater than the spec version *and* it's not a pre-release of the # same version in the spec. return True def _compare_arbitrary(self, prospective: Version, spec: str) -> bool: return str(prospective).lower() == str(spec).lower() @property def prereleases(self) -> bool: # If there is an explicit prereleases set for this, then we'll just # blindly use that. if self._prereleases is not None: return self._prereleases # Look at all of our specifiers and determine if they are inclusive # operators, and if they are if they are including an explicit # prerelease. operator, version = self._spec if operator in ["==", ">=", "<=", "~=", "==="]: # The == specifier can include a trailing .*, if it does we # want to remove before parsing. if operator == "==" and version.endswith(".*"): version = version[:-2] # Parse the version, and if it is a pre-release than this # specifier allows pre-releases. if parse(version).is_prerelease: return True return False @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value _prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") def _version_split(version: str) -> List[str]: result: List[str] = [] for item in version.split("."): match = _prefix_regex.search(item) if match: result.extend(match.groups()) else: result.append(item) return result def _is_not_suffix(segment: str) -> bool: return not any( segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post") ) def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]: left_split, right_split = [], [] # Get the release segment of our versions left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) # Get the rest of our versions left_split.append(left[len(left_split[0]) :]) right_split.append(right[len(right_split[0]) :]) # Insert our padding left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split))) class SpecifierSet(BaseSpecifier): def __init__( self, specifiers: str = "", prereleases: Optional[bool] = None ) -> None: # Split on , to break each individual specifier into it's own item, and # strip each item to remove leading/trailing whitespace. split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] # Parsed each individual specifier, attempting first to make it a # Specifier and falling back to a LegacySpecifier. parsed: Set[_IndividualSpecifier] = set() for specifier in split_specifiers: try: parsed.add(Specifier(specifier)) except InvalidSpecifier: parsed.add(LegacySpecifier(specifier)) # Turn our parsed specifiers into a frozen set and save them for later. self._specs = frozenset(parsed) # Store our prereleases value so we can use it later to determine if # we accept prereleases or not. self._prereleases = prereleases def __repr__(self) -> str: pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return f"<SpecifierSet({str(self)!r}{pre})>" def __str__(self) -> str: return ",".join(sorted(str(s) for s in self._specs)) def __hash__(self) -> int: return hash(self._specs) def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet": if isinstance(other, str): other = SpecifierSet(other) elif not isinstance(other, SpecifierSet): return NotImplemented specifier = SpecifierSet() specifier._specs = frozenset(self._specs | other._specs) if self._prereleases is None and other._prereleases is not None: specifier._prereleases = other._prereleases elif self._prereleases is not None and other._prereleases is None: specifier._prereleases = self._prereleases elif self._prereleases == other._prereleases: specifier._prereleases = self._prereleases else: raise ValueError( "Cannot combine SpecifierSets with True and False prerelease " "overrides." ) return specifier def __eq__(self, other: object) -> bool: if isinstance(other, (str, _IndividualSpecifier)): other = SpecifierSet(str(other)) elif not isinstance(other, SpecifierSet): return NotImplemented return self._specs == other._specs def __len__(self) -> int: return len(self._specs) def __iter__(self) -> Iterator[_IndividualSpecifier]: return iter(self._specs) @property def prereleases(self) -> Optional[bool]: # If we have been given an explicit prerelease modifier, then we'll # pass that through here. if self._prereleases is not None: return self._prereleases # If we don't have any specifiers, and we don't have a forced value, # then we'll just return None since we don't know if this should have # pre-releases or not. if not self._specs: return None # Otherwise we'll see if any of the given specifiers accept # prereleases, if any of them do we'll return True, otherwise False. return any(s.prereleases for s in self._specs) @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value def __contains__(self, item: UnparsedVersion) -> bool: return self.contains(item) def contains( self, item: UnparsedVersion, prereleases: Optional[bool] = None ) -> bool: # Ensure that our item is a Version or LegacyVersion instance. if not isinstance(item, (LegacyVersion, Version)): item = parse(item) # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # We can determine if we're going to allow pre-releases by looking to # see if any of the underlying items supports them. If none of them do # and this item is a pre-release then we do not allow it and we can # short circuit that here. # Note: This means that 1.0.dev1 would not be contained in something # like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 if not prereleases and item.is_prerelease: return False # We simply dispatch to the underlying specs here to make sure that the # given version is contained within all of them. # Note: This use of all() here means that an empty set of specifiers # will always return True, this is an explicit design decision. return all(s.contains(item, prereleases=prereleases) for s in self._specs) def filter( self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None ) -> Iterable[VersionTypeVar]: # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # If we have any specifiers, then we want to wrap our iterable in the # filter method for each one, this will act as a logical AND amongst # each specifier. if self._specs: for spec in self._specs: iterable = spec.filter(iterable, prereleases=bool(prereleases)) return iterable # If we do not have any specifiers, then we need to have a rough filter # which will filter out any pre-releases, unless there are no final # releases, and which will filter out LegacyVersion in general. else: filtered: List[VersionTypeVar] = [] found_prereleases: List[VersionTypeVar] = [] item: UnparsedVersion parsed_version: Union[Version, LegacyVersion] for item in iterable: # Ensure that we some kind of Version class for this item. if not isinstance(item, (LegacyVersion, Version)): parsed_version = parse(item) else: parsed_version = item # Filter out any item which is parsed as a LegacyVersion if isinstance(parsed_version, LegacyVersion): continue # Store any item which is a pre-release for later unless we've # already found a final version or we are accepting prereleases if parsed_version.is_prerelease and not prereleases: if not filtered: found_prereleases.append(item) else: filtered.append(item) # If we've found no items except for pre-releases, then we'll go # ahead and use the pre-releases if not filtered and found_prereleases and prereleases is None: return found_prereleases return filtered utils.py 0000644 00000010150 15030064307 0006251 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import re from typing import FrozenSet, NewType, Tuple, Union, cast from .tags import Tag, parse_tag from .version import InvalidVersion, Version BuildTag = Union[Tuple[()], Tuple[int, str]] NormalizedName = NewType("NormalizedName", str) class InvalidWheelFilename(ValueError): """ An invalid wheel filename was found, users should refer to PEP 427. """ class InvalidSdistFilename(ValueError): """ An invalid sdist filename was found, users should refer to the packaging user guide. """ _canonicalize_regex = re.compile(r"[-_.]+") # PEP 427: The build number must start with a digit. _build_tag_regex = re.compile(r"(\d+)(.*)") def canonicalize_name(name: str) -> NormalizedName: # This is taken from PEP 503. value = _canonicalize_regex.sub("-", name).lower() return cast(NormalizedName, value) def canonicalize_version(version: Union[Version, str]) -> str: """ This is very similar to Version.__str__, but has one subtle difference with the way it handles the release segment. """ if isinstance(version, str): try: parsed = Version(version) except InvalidVersion: # Legacy versions cannot be normalized return version else: parsed = version parts = [] # Epoch if parsed.epoch != 0: parts.append(f"{parsed.epoch}!") # Release segment # NB: This strips trailing '.0's to normalize parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in parsed.release))) # Pre-release if parsed.pre is not None: parts.append("".join(str(x) for x in parsed.pre)) # Post-release if parsed.post is not None: parts.append(f".post{parsed.post}") # Development release if parsed.dev is not None: parts.append(f".dev{parsed.dev}") # Local version segment if parsed.local is not None: parts.append(f"+{parsed.local}") return "".join(parts) def parse_wheel_filename( filename: str, ) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]: if not filename.endswith(".whl"): raise InvalidWheelFilename( f"Invalid wheel filename (extension must be '.whl'): {filename}" ) filename = filename[:-4] dashes = filename.count("-") if dashes not in (4, 5): raise InvalidWheelFilename( f"Invalid wheel filename (wrong number of parts): {filename}" ) parts = filename.split("-", dashes - 2) name_part = parts[0] # See PEP 427 for the rules on escaping the project name if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: raise InvalidWheelFilename(f"Invalid project name: {filename}") name = canonicalize_name(name_part) version = Version(parts[1]) if dashes == 5: build_part = parts[2] build_match = _build_tag_regex.match(build_part) if build_match is None: raise InvalidWheelFilename( f"Invalid build number: {build_part} in '{filename}'" ) build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2))) else: build = () tags = parse_tag(parts[-1]) return (name, version, build, tags) def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]: if filename.endswith(".tar.gz"): file_stem = filename[: -len(".tar.gz")] elif filename.endswith(".zip"): file_stem = filename[: -len(".zip")] else: raise InvalidSdistFilename( f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" f" {filename}" ) # We are requiring a PEP 440 version, which cannot contain dashes, # so we split on the last dash. name_part, sep, version_part = file_stem.rpartition("-") if not sep: raise InvalidSdistFilename(f"Invalid sdist filename: {filename}") name = canonicalize_name(name_part) version = Version(version_part) return (name, version) _parser.py 0000644 00000024153 15030064363 0006556 0 ustar 00 """Handwritten parser of dependency specifiers. The docstring for each __parse_* function contains EBNF-inspired grammar representing the implementation. """ import ast from typing import Any, List, NamedTuple, Optional, Tuple, Union from ._tokenizer import DEFAULT_RULES, Tokenizer class Node: def __init__(self, value: str) -> None: self.value = value def __str__(self) -> str: return self.value def __repr__(self) -> str: return f"<{self.__class__.__name__}('{self}')>" def serialize(self) -> str: raise NotImplementedError class Variable(Node): def serialize(self) -> str: return str(self) class Value(Node): def serialize(self) -> str: return f'"{self}"' class Op(Node): def serialize(self) -> str: return str(self) MarkerVar = Union[Variable, Value] MarkerItem = Tuple[MarkerVar, Op, MarkerVar] # MarkerAtom = Union[MarkerItem, List["MarkerAtom"]] # MarkerList = List[Union["MarkerList", MarkerAtom, str]] # mypy does not support recursive type definition # https://github.com/python/mypy/issues/731 MarkerAtom = Any MarkerList = List[Any] class ParsedRequirement(NamedTuple): name: str url: str extras: List[str] specifier: str marker: Optional[MarkerList] # -------------------------------------------------------------------------------------- # Recursive descent parser for dependency specifier # -------------------------------------------------------------------------------------- def parse_requirement(source: str) -> ParsedRequirement: return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES)) def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement: """ requirement = WS? IDENTIFIER WS? extras WS? requirement_details """ tokenizer.consume("WS") name_token = tokenizer.expect( "IDENTIFIER", expected="package name at the start of dependency specifier" ) name = name_token.text tokenizer.consume("WS") extras = _parse_extras(tokenizer) tokenizer.consume("WS") url, specifier, marker = _parse_requirement_details(tokenizer) tokenizer.expect("END", expected="end of dependency specifier") return ParsedRequirement(name, url, extras, specifier, marker) def _parse_requirement_details( tokenizer: Tokenizer, ) -> Tuple[str, str, Optional[MarkerList]]: """ requirement_details = AT URL (WS requirement_marker?)? | specifier WS? (requirement_marker)? """ specifier = "" url = "" marker = None if tokenizer.check("AT"): tokenizer.read() tokenizer.consume("WS") url_start = tokenizer.position url = tokenizer.expect("URL", expected="URL after @").text if tokenizer.check("END", peek=True): return (url, specifier, marker) tokenizer.expect("WS", expected="whitespace after URL") # The input might end after whitespace. if tokenizer.check("END", peek=True): return (url, specifier, marker) marker = _parse_requirement_marker( tokenizer, span_start=url_start, after="URL and whitespace" ) else: specifier_start = tokenizer.position specifier = _parse_specifier(tokenizer) tokenizer.consume("WS") if tokenizer.check("END", peek=True): return (url, specifier, marker) marker = _parse_requirement_marker( tokenizer, span_start=specifier_start, after=( "version specifier" if specifier else "name and no valid version specifier" ), ) return (url, specifier, marker) def _parse_requirement_marker( tokenizer: Tokenizer, *, span_start: int, after: str ) -> MarkerList: """ requirement_marker = SEMICOLON marker WS? """ if not tokenizer.check("SEMICOLON"): tokenizer.raise_syntax_error( f"Expected end or semicolon (after {after})", span_start=span_start, ) tokenizer.read() marker = _parse_marker(tokenizer) tokenizer.consume("WS") return marker def _parse_extras(tokenizer: Tokenizer) -> List[str]: """ extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? """ if not tokenizer.check("LEFT_BRACKET", peek=True): return [] with tokenizer.enclosing_tokens( "LEFT_BRACKET", "RIGHT_BRACKET", around="extras", ): tokenizer.consume("WS") extras = _parse_extras_list(tokenizer) tokenizer.consume("WS") return extras def _parse_extras_list(tokenizer: Tokenizer) -> List[str]: """ extras_list = identifier (wsp* ',' wsp* identifier)* """ extras: List[str] = [] if not tokenizer.check("IDENTIFIER"): return extras extras.append(tokenizer.read().text) while True: tokenizer.consume("WS") if tokenizer.check("IDENTIFIER", peek=True): tokenizer.raise_syntax_error("Expected comma between extra names") elif not tokenizer.check("COMMA"): break tokenizer.read() tokenizer.consume("WS") extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma") extras.append(extra_token.text) return extras def _parse_specifier(tokenizer: Tokenizer) -> str: """ specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS | WS? version_many WS? """ with tokenizer.enclosing_tokens( "LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", around="version specifier", ): tokenizer.consume("WS") parsed_specifiers = _parse_version_many(tokenizer) tokenizer.consume("WS") return parsed_specifiers def _parse_version_many(tokenizer: Tokenizer) -> str: """ version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? """ parsed_specifiers = "" while tokenizer.check("SPECIFIER"): span_start = tokenizer.position parsed_specifiers += tokenizer.read().text if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True): tokenizer.raise_syntax_error( ".* suffix can only be used with `==` or `!=` operators", span_start=span_start, span_end=tokenizer.position + 1, ) if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True): tokenizer.raise_syntax_error( "Local version label can only be used with `==` or `!=` operators", span_start=span_start, span_end=tokenizer.position, ) tokenizer.consume("WS") if not tokenizer.check("COMMA"): break parsed_specifiers += tokenizer.read().text tokenizer.consume("WS") return parsed_specifiers # -------------------------------------------------------------------------------------- # Recursive descent parser for marker expression # -------------------------------------------------------------------------------------- def parse_marker(source: str) -> MarkerList: return _parse_full_marker(Tokenizer(source, rules=DEFAULT_RULES)) def _parse_full_marker(tokenizer: Tokenizer) -> MarkerList: retval = _parse_marker(tokenizer) tokenizer.expect("END", expected="end of marker expression") return retval def _parse_marker(tokenizer: Tokenizer) -> MarkerList: """ marker = marker_atom (BOOLOP marker_atom)+ """ expression = [_parse_marker_atom(tokenizer)] while tokenizer.check("BOOLOP"): token = tokenizer.read() expr_right = _parse_marker_atom(tokenizer) expression.extend((token.text, expr_right)) return expression def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom: """ marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? | WS? marker_item WS? """ tokenizer.consume("WS") if tokenizer.check("LEFT_PARENTHESIS", peek=True): with tokenizer.enclosing_tokens( "LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", around="marker expression", ): tokenizer.consume("WS") marker: MarkerAtom = _parse_marker(tokenizer) tokenizer.consume("WS") else: marker = _parse_marker_item(tokenizer) tokenizer.consume("WS") return marker def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem: """ marker_item = WS? marker_var WS? marker_op WS? marker_var WS? """ tokenizer.consume("WS") marker_var_left = _parse_marker_var(tokenizer) tokenizer.consume("WS") marker_op = _parse_marker_op(tokenizer) tokenizer.consume("WS") marker_var_right = _parse_marker_var(tokenizer) tokenizer.consume("WS") return (marker_var_left, marker_op, marker_var_right) def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar: """ marker_var = VARIABLE | QUOTED_STRING """ if tokenizer.check("VARIABLE"): return process_env_var(tokenizer.read().text.replace(".", "_")) elif tokenizer.check("QUOTED_STRING"): return process_python_str(tokenizer.read().text) else: tokenizer.raise_syntax_error( message="Expected a marker variable or quoted string" ) def process_env_var(env_var: str) -> Variable: if env_var in ("platform_python_implementation", "python_implementation"): return Variable("platform_python_implementation") else: return Variable(env_var) def process_python_str(python_str: str) -> Value: value = ast.literal_eval(python_str) return Value(str(value)) def _parse_marker_op(tokenizer: Tokenizer) -> Op: """ marker_op = IN | NOT IN | OP """ if tokenizer.check("IN"): tokenizer.read() return Op("in") elif tokenizer.check("NOT"): tokenizer.read() tokenizer.expect("WS", expected="whitespace after 'not'") tokenizer.expect("IN", expected="'in' after 'not'") return Op("not in") elif tokenizer.check("OP"): return Op(tokenizer.read().text) else: return tokenizer.raise_syntax_error( "Expected marker operator, one of " "<=, <, !=, ==, >=, >, ~=, ===, in, not in" ) __pycache__/_parser.cpython-310.pyc 0000644 00000022023 15030064363 0013107 0 ustar 00 o �h�' � @ sx d Z ddlmZ ddlZddlmZmZmZmZ ddl m Z m Z G dd� d�Z G d d � d e �Z G d d � d e �ZG d d� de �Zee ef Zeeeef Zeeed f Zeedeef ZG dd� de�ZdCdd�ZdDdd�ZdEd d �ZdFd"d#�ZdGd%d&�ZdGd'd(�ZdHd)d*�Z dHd+d,�Z dId-d.�Z dJd/d0�Z dJd1d2�Z dKd3d4�Z!dLd6d7�Z"dMd9d:�Z#dNd<d=�Z$dOd?d@�Z%dPdAdB�Z&dS )Qz�Handwritten parser of dependency specifiers. The docstring for each __parse_* function contains EBNF-inspired grammar representing the implementation. � )� annotationsN)� NamedTuple�Sequence�Tuple�Union� )� DEFAULT_RULES� Tokenizerc @ s4 e Zd Zddd�Zddd�Zdd d �Zdd d �Zd S )�Node�value�str�return�Nonec C s || _ d S �N�r )�selfr � r �G/usr/local/CyberPanel/lib/python3.10/site-packages/packaging/_parser.py�__init__ s z Node.__init__c C s | j S r r �r r r r �__str__ s z Node.__str__c C s d| j j� d| � d�S )N�<z('z')>)� __class__�__name__r r r r �__repr__ s z Node.__repr__c C s t �r )�NotImplementedErrorr r r r � serialize s zNode.serializeN)r r r r �r r )r � __module__� __qualname__r r r r r r r r r s r c @ � e Zd Zddd�ZdS )�Variabler r c C � t | �S r �r r r r r r � zVariable.serializeNr �r r r r r r r r r! � r! c @ r )�Valuer r c C s d| � d�S )N�"r r r r r r # s zValue.serializeNr r% r r r r r' " r& r' c @ r )�Opr r c C r" r r# r r r r r ( r$ z Op.serializeNr r% r r r r r) ' r& r) � MarkerAtom� MarkerListc @ s6 e Zd ZU ded< ded< ded< ded< ded< d S ) �ParsedRequirementr �name�url� list[str]�extras� specifierzMarkerList | None�markerN)r r r �__annotations__r r r r r, 2 s r, �sourcer r c C � t t| td��S �N)�rules)�_parse_requirementr r �r4 r r r �parse_requirement= � r: � tokenizerr c C sf | � d� | jddd�}|j}| � d� t| �}| � d� t| �\}}}| jddd� t|||||�S )zI requirement = WS? IDENTIFIER WS? extras WS? requirement_details �WS� IDENTIFIERz1package name at the start of dependency specifier��expected�ENDzend of dependency specifier)�consume�expect�text� _parse_extras�_parse_requirement_detailsr, )r< � name_tokenr- r0 r. r1 r2 r r r r8 A s � r8 �"tuple[str, str, MarkerList | None]c C s� d}d}d}| � d�rF| �� | �d� | j}| jddd�j}| j dd d �r+|||fS | jdd d� | j dd d �r>|||fS t| |d d �}n#| j}t| �}| �d� | j dd d �r^|||fS t| ||redndd �}|||fS )z~ requirement_details = AT URL (WS requirement_marker?)? | specifier WS? (requirement_marker)? � N�ATr= �URLz URL after @r? rA T��peekzwhitespace after URLzURL and whitespace)� span_start�after�version specifierz#name and no valid version specifier)�check�readrB �positionrC rD �_parse_requirement_marker�_parse_specifier)r< r1 r. r2 � url_start�specifier_startr r r rF V s: � �� rF rN �intrO c C s> | � d�s| jd|� d�|d� | �� t| �}| �d� |S )z3 requirement_marker = SEMICOLON marker WS? � SEMICOLONz!Expected end or semicolon (after �))rN r= )rQ �raise_syntax_errorrR � _parse_markerrB )r< rN rO r2 r r r rT � s � rT r/ c C sd | j ddd�s g S | jdddd�� | �d� t| �}| �d� W d � |S 1 s+w Y |S ) zG extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? � LEFT_BRACKETTrL � RIGHT_BRACKETr0 ��aroundr= N)rQ �enclosing_tokensrB �_parse_extras_list)r< r0 r r r rE � s � � � rE c C s� g }| � d�s |S |�| �� j� | �d� | j ddd�r$| �d� n| � d�s, |S | �� | �d� | jddd�}|�|j� q) z> extras_list = identifier (wsp* ',' wsp* identifier)* r> Tr= rL z"Expected comma between extra names�COMMAzextra name after commar? )rQ �appendrR rD rB r[ rC )r< r0 � extra_tokenr r r rb � s � �rb c C sR | j dddd�� | �d� t| �}| �d� W d � |S 1 s"w Y |S )zr specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS | WS? version_many WS? �LEFT_PARENTHESIS�RIGHT_PARENTHESISrP r_ r= N)ra rB �_parse_version_many)r< �parsed_specifiersr r r rU � s � � � rU c C s� d}| � d�rQ| j}|| �� j7 }| j ddd�r#| jd|| jd d� | j d dd�r3| jd || jd� | �d � | � d �s@ |S || �� j7 }| �d � | � d�s|S ) z@ version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? rI � SPECIFIER�VERSION_PREFIX_TRAILTrL z6.* suffix can only be used with `==` or `!=` operatorsr )rN �span_end�VERSION_LOCAL_LABEL_TRAILz@Local version label can only be used with `==` or `!=` operatorsr= rc )rQ rS rR rD r[ rB )r< ri rN r r r rh � s0 �� � �rh c C r5 r6 )�_parse_full_markerr r r9 r r r � parse_marker� r; ro c C s t | �}| jddd� |S )NrA zend of marker expressionr? )r\ rC )r< �retvalr r r rn s rn c C sB t | �g}| �d�r | �� }t | �}|�|j|f� | �d�s |S )z4 marker = marker_atom (BOOLOP marker_atom)+ �BOOLOP)�_parse_marker_atomrQ rR �extendrD )r< � expression�token� expr_rightr r r r\ s �r\ c C s| | � d� | jddd�r3| jdddd�� | � d� t| �}| � d� W d � n1 s-w Y nt| �}| � d� |S ) zw marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? | WS? marker_item WS? r= rf TrL rg zmarker expressionr_ N)rB rQ ra r\ �_parse_marker_item)r< r2 r r r rr s � �� rr � MarkerItemc C sJ | � d� t| �}| � d� t| �}| � d� t| �}| � d� |||fS )zG marker_item = WS? marker_var WS? marker_op WS? marker_var WS? r= )rB �_parse_marker_var�_parse_marker_op)r< �marker_var_left� marker_op�marker_var_rightr r r rw ( s rw � MarkerVarc C sH | � d�rt| �� j�dd��S | � d�r t| �� j�S | jdd� dS )z/ marker_var = VARIABLE | QUOTED_STRING �VARIABLE�.�_� QUOTED_STRINGz+Expected a marker variable or quoted string)�messageN)rQ �process_env_varrR rD �replace�process_python_strr[ �r< r r r ry 6 s �ry �env_varc C s | dv rt d�S t | �S )N)� platform_python_implementation�python_implementationr� )r! )r� r r r r� D s r� � python_strc C s t �| �}tt|��S r )�ast� literal_evalr' r )r� r r r r r� K s r� c C sr | � d�r | �� td�S | � d�r(| �� | jddd� | jddd� td�S | � d �r4t| �� j�S | �d �S ) z& marker_op = IN | NOT IN | OP �IN�in�NOTr= zwhitespace after 'not'r? z'in' after 'not'znot in�OPzJExpected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in)rQ rR r) rC rD r[ r� r r r rz P s �rz )r4 r r r, )r< r r r, )r< r r rH )r< r rN rX rO r r r+ )r< r r r/ )r< r r r )r4 r r r+ )r< r r r+ )r< r r r* )r< r r rx )r< r r r~ )r� r r r! )r� r r r' )r< r r r) )'�__doc__� __future__r r� �typingr r r r � _tokenizerr r r r! r' r) r~ rx r* r r+ r, r: r8 rF rT rE rb rU rh ro rn r\ rr rw ry r� r� rz r r r r �<module> s> 3 __pycache__/_elffile.cpython-310.pyc 0000644 00000006446 15030064363 0013234 0 ustar 00 o �h� � @ s� d Z ddlmZ ddlZddlZddlZddlmZ G dd� de�Z G dd� dej �Z G d d � d ej �Z G d d � d ej �Z G d d� d�ZdS )a; ELF file parser. This provides a class ``ELFFile`` that parses an ELF executable in a similar interface to ``ZipFile``. Only the read interface is implemented. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html � )� annotationsN)�IOc @ s e Zd ZdS )� ELFInvalidN)�__name__� __module__� __qualname__� r r �H/usr/local/CyberPanel/lib/python3.10/site-packages/packaging/_elffile.pyr s r c @ � e Zd ZdZdZdS )�EIClass� � N)r r r �C32�C64r r r r r � r c @ r )�EIDatar r N)r r r �Lsb�Msbr r r r r r r c @ s e Zd ZdZdZdZdZdZdS )�EMachine� � �( �> � N)r r r �I386�S390�Arm�X8664�AArc64r r r r r ! s r c @ s2 e Zd ZdZddd�Zdd d �Zeddd��ZdS )�ELFFilez. Representation of an ELF executable. �f� IO[bytes]�return�Nonec C s& || _ z| �d�}W n tjy } ztd�|�d }~ww t|d d� �}|dkr0td|����|d | _|d | _zddd d d �| j| jf \}| _| _ W n t yh } ztd | j� d | j� d��|�d }~ww z| �|�\ }| _ }}| _ }| _ }| _| _W d S tjy� } ztd�|�d }~ww )N�16Bz unable to parse identification� s ELFzinvalid magic: � )z <HHIIIIIHHHz <IIIIIIII�r r r% )z >HHIIIIIHHHz >IIIIIIIIr' )z <HHIQQQIHHHz <IIQQQQQQ�r r r& )z >HHIQQQIHHHz >IIQQQQQQr( ))r r )r r )r r )r r zunrecognized capacity (z) or encoding (�)z/unable to parse machine and section information)�_f�_read�struct�errorr �bytes�capacity�encoding�_p_fmt�_p_idx�KeyError�machine�_e_phoff�flags� _e_phentsize�_e_phnum)�selfr �ident�e�magic�e_fmt�_r r r �__init__. sZ �� � ����� � ��zELFFile.__init__�fmt�str�tuple[int, ...]c C s t �|| j�t �|���S )N)r, �unpackr* �read�calcsize)r9 r@ r r r r+ [ s z ELFFile._read� str | Nonec C s� t | j�D ]H}| j�| j| j| � z| �| j�}W n tj y% Y qw || j d dkr0q| j�|| j d � t � | j� || j d ���d� S dS )zH The path recorded in the ``PT_INTERP`` section header. r r r r � N)�ranger8 r* �seekr5 r7 r+ r1 r, r- r2 �os�fsdecoderD �strip)r9 �index�datar r r � interpreter^ s �&zELFFile.interpreterN)r r! r" r# )r@ rA r" rB )r" rF )r r r �__doc__r? r+ �propertyrO r r r r r ) s -r )rP � __future__r �enumrJ r, �typingr � ValueErrorr �IntEnumr r r r r r r r �<module> s __pycache__/_tokenizer.cpython-310.pyc 0000644 00000013446 15030064363 0013636 0 ustar 00 o �h� � @ s$ U d dl mZ d dlZd dlZd dlmZ d dlmZmZ ddl m Z eG dd� d��Z G d d � d e �Z i d d �d d�dd�dd�dd�dd�de�dej��dd�dd �d d �d d �d!e�d"ej��d#e�e je j ejejB ��d$d%�d&d'�d(d)�d*d+�d,d-d.d/��Zd0ed1< G d2d3� d3�ZdS )4� )� annotationsN)� dataclass)�Iterator�NoReturn� )� Specifierc @ s& e Zd ZU ded< ded< ded< dS )�Token�str�name�text�int�positionN)�__name__� __module__� __qualname__�__annotations__� r r �J/usr/local/CyberPanel/lib/python3.10/site-packages/packaging/_tokenizer.pyr s r c s, e Zd ZdZd � fd d � Zdd d �Z� ZS )�ParserSyntaxErrorz7The provided source text could not be parsed correctly.�messager �source�span�tuple[int, int]�return�Nonec s || _ || _|| _t� �� d S )N)r r r �super�__init__)�selfr r r �� __class__r r r s zParserSyntaxError.__init__c C s> d| j d d| j d | j d d }d�| j| j|g�S )N� r �~r �^z )r �joinr r )r �markerr r r �__str__" s *zParserSyntaxError.__str__)r r r r r r r r )r r )r r r �__doc__r r% � __classcell__r r r r r s r �LEFT_PARENTHESISz\(�RIGHT_PARENTHESISz\)� LEFT_BRACKETz\[� RIGHT_BRACKETz\]� SEMICOLON�;�COMMA�,� QUOTED_STRINGzk ( ('[^']*') | ("[^"]*") ) �OPz(===|==|~=|!=|<=|>=|<|>)�BOOLOPz \b(or|and)\b�INz\bin\b�NOTz\bnot\b�VARIABLEa� \b( python_version |python_full_version |os[._]name |sys[._]platform |platform_(release|system) |platform[._](version|machine|python_implementation) |python_implementation |implementation_(name|version) |extras? |dependency_groups )\b � SPECIFIER�ATz\@�URLz[^ \t]+� IDENTIFIERz \b[a-zA-Z0-9][a-zA-Z0-9._-]*\b�VERSION_PREFIX_TRAILz\.\*z \+[a-z0-9]+(?:[-_\.][a-z0-9]+)*z[ \t]+�$)�VERSION_LOCAL_LABEL_TRAIL�WS�END� dict[str, str | re.Pattern[str]]� DEFAULT_RULESc @ sj e Zd ZdZd(dd �Zd)d d �Zd d�d*dd�Zd+dd�Zd,dd�Zddd�d-d d!�Z e j d.d&d'��Z dS )/� Tokenizerz�Context-sensitive token parsing. Provides methods to examine the input stream to check whether the next token matches. r r �rulesr? r r c C s* || _ dd� |�� D �| _d | _d| _d S )Nc S s i | ] \}}|t �|��qS r )�re�compile)�.0r �patternr r r � <dictcomp>i s �z&Tokenizer.__init__.<locals>.<dictcomp>r )r �itemsrB � next_tokenr )r r rB r r r r b s � zTokenizer.__init__r c C s | � |�r | �� dS dS )z8Move beyond provided token name, if at current position.N)�check�read)r r r r r �consumeo s �zTokenizer.consumeF)�peekrM �boolc C sz | j du sJ d|�d| j ����|| jv s J d|����| j| }|�| j| j�}|du r/dS |s;t||d | j�| _ dS )z�Check whether the next token has the provided name. By default, if the check succeeds, the token *must* be read before another check. If `peek` is set to `True`, the token is not loaded and would need to be checked again. NzCannot check for z, already have zUnknown token name: Fr T)rI rB �matchr r r )r r rM � expressionrO r r r rJ t s � zTokenizer.check�expectedr c C s" | � |�s | �d|� ���| �� S )zsExpect a certain token name next, failing with a syntax error otherwise. The token is *not* read. z Expected )rJ �raise_syntax_errorrK )r r rQ r r r �expect� s zTokenizer.expectc C s0 | j }|dus J �| jt|j�7 _d| _ |S )z%Consume the next token and return it.N)rI r �lenr )r �tokenr r r rK � s zTokenizer.readN)� span_start�span_endr rV � int | NonerW r c C s4 |du r| j n||du r| j n|f}t|| j|d��)z.Raise ParserSyntaxError at the given position.N)r r )r r r )r r rV rW r r r r rR � s ��z Tokenizer.raise_syntax_error� open_token� close_token�around�Iterator[None]c c sh � | � |�r| j}| �� nd }d V |d u rd S | � |�s.| jd|� d|� d|� �|d� | �� d S )NzExpected matching z for z, after )rV )rJ r rK rR )r rY rZ r[ � open_positionr r r �enclosing_tokens� s � � zTokenizer.enclosing_tokens)r r rB r? r r )r r r r )r r rM rN r rN )r r rQ r r r )r r )r r rV rX rW rX r r )rY r rZ r r[ r r r\ ) r r r r& r rL rJ rS rK rR � contextlib�contextmanagerr^ r r r r rA [ s �rA )� __future__r r_ rC � dataclassesr �typingr r � specifiersr r � Exceptionr rD �VERBOSE�_operator_regex_str�_version_regex_str� IGNORECASEr@ r rA r r r r �<module> st ��������������& ��*�+�,�-�.�4 licenses/_spdx.py 0000644 00000136416 15030064363 0010053 0 ustar 00 from __future__ import annotations from typing import TypedDict class SPDXLicense(TypedDict): id: str deprecated: bool class SPDXException(TypedDict): id: str deprecated: bool VERSION = '3.25.0' LICENSES: dict[str, SPDXLicense] = { '0bsd': {'id': '0BSD', 'deprecated': False}, '3d-slicer-1.0': {'id': '3D-Slicer-1.0', 'deprecated': False}, 'aal': {'id': 'AAL', 'deprecated': False}, 'abstyles': {'id': 'Abstyles', 'deprecated': False}, 'adacore-doc': {'id': 'AdaCore-doc', 'deprecated': False}, 'adobe-2006': {'id': 'Adobe-2006', 'deprecated': False}, 'adobe-display-postscript': {'id': 'Adobe-Display-PostScript', 'deprecated': False}, 'adobe-glyph': {'id': 'Adobe-Glyph', 'deprecated': False}, 'adobe-utopia': {'id': 'Adobe-Utopia', 'deprecated': False}, 'adsl': {'id': 'ADSL', 'deprecated': False}, 'afl-1.1': {'id': 'AFL-1.1', 'deprecated': False}, 'afl-1.2': {'id': 'AFL-1.2', 'deprecated': False}, 'afl-2.0': {'id': 'AFL-2.0', 'deprecated': False}, 'afl-2.1': {'id': 'AFL-2.1', 'deprecated': False}, 'afl-3.0': {'id': 'AFL-3.0', 'deprecated': False}, 'afmparse': {'id': 'Afmparse', 'deprecated': False}, 'agpl-1.0': {'id': 'AGPL-1.0', 'deprecated': True}, 'agpl-1.0-only': {'id': 'AGPL-1.0-only', 'deprecated': False}, 'agpl-1.0-or-later': {'id': 'AGPL-1.0-or-later', 'deprecated': False}, 'agpl-3.0': {'id': 'AGPL-3.0', 'deprecated': True}, 'agpl-3.0-only': {'id': 'AGPL-3.0-only', 'deprecated': False}, 'agpl-3.0-or-later': {'id': 'AGPL-3.0-or-later', 'deprecated': False}, 'aladdin': {'id': 'Aladdin', 'deprecated': False}, 'amd-newlib': {'id': 'AMD-newlib', 'deprecated': False}, 'amdplpa': {'id': 'AMDPLPA', 'deprecated': False}, 'aml': {'id': 'AML', 'deprecated': False}, 'aml-glslang': {'id': 'AML-glslang', 'deprecated': False}, 'ampas': {'id': 'AMPAS', 'deprecated': False}, 'antlr-pd': {'id': 'ANTLR-PD', 'deprecated': False}, 'antlr-pd-fallback': {'id': 'ANTLR-PD-fallback', 'deprecated': False}, 'any-osi': {'id': 'any-OSI', 'deprecated': False}, 'apache-1.0': {'id': 'Apache-1.0', 'deprecated': False}, 'apache-1.1': {'id': 'Apache-1.1', 'deprecated': False}, 'apache-2.0': {'id': 'Apache-2.0', 'deprecated': False}, 'apafml': {'id': 'APAFML', 'deprecated': False}, 'apl-1.0': {'id': 'APL-1.0', 'deprecated': False}, 'app-s2p': {'id': 'App-s2p', 'deprecated': False}, 'apsl-1.0': {'id': 'APSL-1.0', 'deprecated': False}, 'apsl-1.1': {'id': 'APSL-1.1', 'deprecated': False}, 'apsl-1.2': {'id': 'APSL-1.2', 'deprecated': False}, 'apsl-2.0': {'id': 'APSL-2.0', 'deprecated': False}, 'arphic-1999': {'id': 'Arphic-1999', 'deprecated': False}, 'artistic-1.0': {'id': 'Artistic-1.0', 'deprecated': False}, 'artistic-1.0-cl8': {'id': 'Artistic-1.0-cl8', 'deprecated': False}, 'artistic-1.0-perl': {'id': 'Artistic-1.0-Perl', 'deprecated': False}, 'artistic-2.0': {'id': 'Artistic-2.0', 'deprecated': False}, 'aswf-digital-assets-1.0': {'id': 'ASWF-Digital-Assets-1.0', 'deprecated': False}, 'aswf-digital-assets-1.1': {'id': 'ASWF-Digital-Assets-1.1', 'deprecated': False}, 'baekmuk': {'id': 'Baekmuk', 'deprecated': False}, 'bahyph': {'id': 'Bahyph', 'deprecated': False}, 'barr': {'id': 'Barr', 'deprecated': False}, 'bcrypt-solar-designer': {'id': 'bcrypt-Solar-Designer', 'deprecated': False}, 'beerware': {'id': 'Beerware', 'deprecated': False}, 'bitstream-charter': {'id': 'Bitstream-Charter', 'deprecated': False}, 'bitstream-vera': {'id': 'Bitstream-Vera', 'deprecated': False}, 'bittorrent-1.0': {'id': 'BitTorrent-1.0', 'deprecated': False}, 'bittorrent-1.1': {'id': 'BitTorrent-1.1', 'deprecated': False}, 'blessing': {'id': 'blessing', 'deprecated': False}, 'blueoak-1.0.0': {'id': 'BlueOak-1.0.0', 'deprecated': False}, 'boehm-gc': {'id': 'Boehm-GC', 'deprecated': False}, 'borceux': {'id': 'Borceux', 'deprecated': False}, 'brian-gladman-2-clause': {'id': 'Brian-Gladman-2-Clause', 'deprecated': False}, 'brian-gladman-3-clause': {'id': 'Brian-Gladman-3-Clause', 'deprecated': False}, 'bsd-1-clause': {'id': 'BSD-1-Clause', 'deprecated': False}, 'bsd-2-clause': {'id': 'BSD-2-Clause', 'deprecated': False}, 'bsd-2-clause-darwin': {'id': 'BSD-2-Clause-Darwin', 'deprecated': False}, 'bsd-2-clause-first-lines': {'id': 'BSD-2-Clause-first-lines', 'deprecated': False}, 'bsd-2-clause-freebsd': {'id': 'BSD-2-Clause-FreeBSD', 'deprecated': True}, 'bsd-2-clause-netbsd': {'id': 'BSD-2-Clause-NetBSD', 'deprecated': True}, 'bsd-2-clause-patent': {'id': 'BSD-2-Clause-Patent', 'deprecated': False}, 'bsd-2-clause-views': {'id': 'BSD-2-Clause-Views', 'deprecated': False}, 'bsd-3-clause': {'id': 'BSD-3-Clause', 'deprecated': False}, 'bsd-3-clause-acpica': {'id': 'BSD-3-Clause-acpica', 'deprecated': False}, 'bsd-3-clause-attribution': {'id': 'BSD-3-Clause-Attribution', 'deprecated': False}, 'bsd-3-clause-clear': {'id': 'BSD-3-Clause-Clear', 'deprecated': False}, 'bsd-3-clause-flex': {'id': 'BSD-3-Clause-flex', 'deprecated': False}, 'bsd-3-clause-hp': {'id': 'BSD-3-Clause-HP', 'deprecated': False}, 'bsd-3-clause-lbnl': {'id': 'BSD-3-Clause-LBNL', 'deprecated': False}, 'bsd-3-clause-modification': {'id': 'BSD-3-Clause-Modification', 'deprecated': False}, 'bsd-3-clause-no-military-license': {'id': 'BSD-3-Clause-No-Military-License', 'deprecated': False}, 'bsd-3-clause-no-nuclear-license': {'id': 'BSD-3-Clause-No-Nuclear-License', 'deprecated': False}, 'bsd-3-clause-no-nuclear-license-2014': {'id': 'BSD-3-Clause-No-Nuclear-License-2014', 'deprecated': False}, 'bsd-3-clause-no-nuclear-warranty': {'id': 'BSD-3-Clause-No-Nuclear-Warranty', 'deprecated': False}, 'bsd-3-clause-open-mpi': {'id': 'BSD-3-Clause-Open-MPI', 'deprecated': False}, 'bsd-3-clause-sun': {'id': 'BSD-3-Clause-Sun', 'deprecated': False}, 'bsd-4-clause': {'id': 'BSD-4-Clause', 'deprecated': False}, 'bsd-4-clause-shortened': {'id': 'BSD-4-Clause-Shortened', 'deprecated': False}, 'bsd-4-clause-uc': {'id': 'BSD-4-Clause-UC', 'deprecated': False}, 'bsd-4.3reno': {'id': 'BSD-4.3RENO', 'deprecated': False}, 'bsd-4.3tahoe': {'id': 'BSD-4.3TAHOE', 'deprecated': False}, 'bsd-advertising-acknowledgement': {'id': 'BSD-Advertising-Acknowledgement', 'deprecated': False}, 'bsd-attribution-hpnd-disclaimer': {'id': 'BSD-Attribution-HPND-disclaimer', 'deprecated': False}, 'bsd-inferno-nettverk': {'id': 'BSD-Inferno-Nettverk', 'deprecated': False}, 'bsd-protection': {'id': 'BSD-Protection', 'deprecated': False}, 'bsd-source-beginning-file': {'id': 'BSD-Source-beginning-file', 'deprecated': False}, 'bsd-source-code': {'id': 'BSD-Source-Code', 'deprecated': False}, 'bsd-systemics': {'id': 'BSD-Systemics', 'deprecated': False}, 'bsd-systemics-w3works': {'id': 'BSD-Systemics-W3Works', 'deprecated': False}, 'bsl-1.0': {'id': 'BSL-1.0', 'deprecated': False}, 'busl-1.1': {'id': 'BUSL-1.1', 'deprecated': False}, 'bzip2-1.0.5': {'id': 'bzip2-1.0.5', 'deprecated': True}, 'bzip2-1.0.6': {'id': 'bzip2-1.0.6', 'deprecated': False}, 'c-uda-1.0': {'id': 'C-UDA-1.0', 'deprecated': False}, 'cal-1.0': {'id': 'CAL-1.0', 'deprecated': False}, 'cal-1.0-combined-work-exception': {'id': 'CAL-1.0-Combined-Work-Exception', 'deprecated': False}, 'caldera': {'id': 'Caldera', 'deprecated': False}, 'caldera-no-preamble': {'id': 'Caldera-no-preamble', 'deprecated': False}, 'catharon': {'id': 'Catharon', 'deprecated': False}, 'catosl-1.1': {'id': 'CATOSL-1.1', 'deprecated': False}, 'cc-by-1.0': {'id': 'CC-BY-1.0', 'deprecated': False}, 'cc-by-2.0': {'id': 'CC-BY-2.0', 'deprecated': False}, 'cc-by-2.5': {'id': 'CC-BY-2.5', 'deprecated': False}, 'cc-by-2.5-au': {'id': 'CC-BY-2.5-AU', 'deprecated': False}, 'cc-by-3.0': {'id': 'CC-BY-3.0', 'deprecated': False}, 'cc-by-3.0-at': {'id': 'CC-BY-3.0-AT', 'deprecated': False}, 'cc-by-3.0-au': {'id': 'CC-BY-3.0-AU', 'deprecated': False}, 'cc-by-3.0-de': {'id': 'CC-BY-3.0-DE', 'deprecated': False}, 'cc-by-3.0-igo': {'id': 'CC-BY-3.0-IGO', 'deprecated': False}, 'cc-by-3.0-nl': {'id': 'CC-BY-3.0-NL', 'deprecated': False}, 'cc-by-3.0-us': {'id': 'CC-BY-3.0-US', 'deprecated': False}, 'cc-by-4.0': {'id': 'CC-BY-4.0', 'deprecated': False}, 'cc-by-nc-1.0': {'id': 'CC-BY-NC-1.0', 'deprecated': False}, 'cc-by-nc-2.0': {'id': 'CC-BY-NC-2.0', 'deprecated': False}, 'cc-by-nc-2.5': {'id': 'CC-BY-NC-2.5', 'deprecated': False}, 'cc-by-nc-3.0': {'id': 'CC-BY-NC-3.0', 'deprecated': False}, 'cc-by-nc-3.0-de': {'id': 'CC-BY-NC-3.0-DE', 'deprecated': False}, 'cc-by-nc-4.0': {'id': 'CC-BY-NC-4.0', 'deprecated': False}, 'cc-by-nc-nd-1.0': {'id': 'CC-BY-NC-ND-1.0', 'deprecated': False}, 'cc-by-nc-nd-2.0': {'id': 'CC-BY-NC-ND-2.0', 'deprecated': False}, 'cc-by-nc-nd-2.5': {'id': 'CC-BY-NC-ND-2.5', 'deprecated': False}, 'cc-by-nc-nd-3.0': {'id': 'CC-BY-NC-ND-3.0', 'deprecated': False}, 'cc-by-nc-nd-3.0-de': {'id': 'CC-BY-NC-ND-3.0-DE', 'deprecated': False}, 'cc-by-nc-nd-3.0-igo': {'id': 'CC-BY-NC-ND-3.0-IGO', 'deprecated': False}, 'cc-by-nc-nd-4.0': {'id': 'CC-BY-NC-ND-4.0', 'deprecated': False}, 'cc-by-nc-sa-1.0': {'id': 'CC-BY-NC-SA-1.0', 'deprecated': False}, 'cc-by-nc-sa-2.0': {'id': 'CC-BY-NC-SA-2.0', 'deprecated': False}, 'cc-by-nc-sa-2.0-de': {'id': 'CC-BY-NC-SA-2.0-DE', 'deprecated': False}, 'cc-by-nc-sa-2.0-fr': {'id': 'CC-BY-NC-SA-2.0-FR', 'deprecated': False}, 'cc-by-nc-sa-2.0-uk': {'id': 'CC-BY-NC-SA-2.0-UK', 'deprecated': False}, 'cc-by-nc-sa-2.5': {'id': 'CC-BY-NC-SA-2.5', 'deprecated': False}, 'cc-by-nc-sa-3.0': {'id': 'CC-BY-NC-SA-3.0', 'deprecated': False}, 'cc-by-nc-sa-3.0-de': {'id': 'CC-BY-NC-SA-3.0-DE', 'deprecated': False}, 'cc-by-nc-sa-3.0-igo': {'id': 'CC-BY-NC-SA-3.0-IGO', 'deprecated': False}, 'cc-by-nc-sa-4.0': {'id': 'CC-BY-NC-SA-4.0', 'deprecated': False}, 'cc-by-nd-1.0': {'id': 'CC-BY-ND-1.0', 'deprecated': False}, 'cc-by-nd-2.0': {'id': 'CC-BY-ND-2.0', 'deprecated': False}, 'cc-by-nd-2.5': {'id': 'CC-BY-ND-2.5', 'deprecated': False}, 'cc-by-nd-3.0': {'id': 'CC-BY-ND-3.0', 'deprecated': False}, 'cc-by-nd-3.0-de': {'id': 'CC-BY-ND-3.0-DE', 'deprecated': False}, 'cc-by-nd-4.0': {'id': 'CC-BY-ND-4.0', 'deprecated': False}, 'cc-by-sa-1.0': {'id': 'CC-BY-SA-1.0', 'deprecated': False}, 'cc-by-sa-2.0': {'id': 'CC-BY-SA-2.0', 'deprecated': False}, 'cc-by-sa-2.0-uk': {'id': 'CC-BY-SA-2.0-UK', 'deprecated': False}, 'cc-by-sa-2.1-jp': {'id': 'CC-BY-SA-2.1-JP', 'deprecated': False}, 'cc-by-sa-2.5': {'id': 'CC-BY-SA-2.5', 'deprecated': False}, 'cc-by-sa-3.0': {'id': 'CC-BY-SA-3.0', 'deprecated': False}, 'cc-by-sa-3.0-at': {'id': 'CC-BY-SA-3.0-AT', 'deprecated': False}, 'cc-by-sa-3.0-de': {'id': 'CC-BY-SA-3.0-DE', 'deprecated': False}, 'cc-by-sa-3.0-igo': {'id': 'CC-BY-SA-3.0-IGO', 'deprecated': False}, 'cc-by-sa-4.0': {'id': 'CC-BY-SA-4.0', 'deprecated': False}, 'cc-pddc': {'id': 'CC-PDDC', 'deprecated': False}, 'cc0-1.0': {'id': 'CC0-1.0', 'deprecated': False}, 'cddl-1.0': {'id': 'CDDL-1.0', 'deprecated': False}, 'cddl-1.1': {'id': 'CDDL-1.1', 'deprecated': False}, 'cdl-1.0': {'id': 'CDL-1.0', 'deprecated': False}, 'cdla-permissive-1.0': {'id': 'CDLA-Permissive-1.0', 'deprecated': False}, 'cdla-permissive-2.0': {'id': 'CDLA-Permissive-2.0', 'deprecated': False}, 'cdla-sharing-1.0': {'id': 'CDLA-Sharing-1.0', 'deprecated': False}, 'cecill-1.0': {'id': 'CECILL-1.0', 'deprecated': False}, 'cecill-1.1': {'id': 'CECILL-1.1', 'deprecated': False}, 'cecill-2.0': {'id': 'CECILL-2.0', 'deprecated': False}, 'cecill-2.1': {'id': 'CECILL-2.1', 'deprecated': False}, 'cecill-b': {'id': 'CECILL-B', 'deprecated': False}, 'cecill-c': {'id': 'CECILL-C', 'deprecated': False}, 'cern-ohl-1.1': {'id': 'CERN-OHL-1.1', 'deprecated': False}, 'cern-ohl-1.2': {'id': 'CERN-OHL-1.2', 'deprecated': False}, 'cern-ohl-p-2.0': {'id': 'CERN-OHL-P-2.0', 'deprecated': False}, 'cern-ohl-s-2.0': {'id': 'CERN-OHL-S-2.0', 'deprecated': False}, 'cern-ohl-w-2.0': {'id': 'CERN-OHL-W-2.0', 'deprecated': False}, 'cfitsio': {'id': 'CFITSIO', 'deprecated': False}, 'check-cvs': {'id': 'check-cvs', 'deprecated': False}, 'checkmk': {'id': 'checkmk', 'deprecated': False}, 'clartistic': {'id': 'ClArtistic', 'deprecated': False}, 'clips': {'id': 'Clips', 'deprecated': False}, 'cmu-mach': {'id': 'CMU-Mach', 'deprecated': False}, 'cmu-mach-nodoc': {'id': 'CMU-Mach-nodoc', 'deprecated': False}, 'cnri-jython': {'id': 'CNRI-Jython', 'deprecated': False}, 'cnri-python': {'id': 'CNRI-Python', 'deprecated': False}, 'cnri-python-gpl-compatible': {'id': 'CNRI-Python-GPL-Compatible', 'deprecated': False}, 'coil-1.0': {'id': 'COIL-1.0', 'deprecated': False}, 'community-spec-1.0': {'id': 'Community-Spec-1.0', 'deprecated': False}, 'condor-1.1': {'id': 'Condor-1.1', 'deprecated': False}, 'copyleft-next-0.3.0': {'id': 'copyleft-next-0.3.0', 'deprecated': False}, 'copyleft-next-0.3.1': {'id': 'copyleft-next-0.3.1', 'deprecated': False}, 'cornell-lossless-jpeg': {'id': 'Cornell-Lossless-JPEG', 'deprecated': False}, 'cpal-1.0': {'id': 'CPAL-1.0', 'deprecated': False}, 'cpl-1.0': {'id': 'CPL-1.0', 'deprecated': False}, 'cpol-1.02': {'id': 'CPOL-1.02', 'deprecated': False}, 'cronyx': {'id': 'Cronyx', 'deprecated': False}, 'crossword': {'id': 'Crossword', 'deprecated': False}, 'crystalstacker': {'id': 'CrystalStacker', 'deprecated': False}, 'cua-opl-1.0': {'id': 'CUA-OPL-1.0', 'deprecated': False}, 'cube': {'id': 'Cube', 'deprecated': False}, 'curl': {'id': 'curl', 'deprecated': False}, 'cve-tou': {'id': 'cve-tou', 'deprecated': False}, 'd-fsl-1.0': {'id': 'D-FSL-1.0', 'deprecated': False}, 'dec-3-clause': {'id': 'DEC-3-Clause', 'deprecated': False}, 'diffmark': {'id': 'diffmark', 'deprecated': False}, 'dl-de-by-2.0': {'id': 'DL-DE-BY-2.0', 'deprecated': False}, 'dl-de-zero-2.0': {'id': 'DL-DE-ZERO-2.0', 'deprecated': False}, 'doc': {'id': 'DOC', 'deprecated': False}, 'docbook-schema': {'id': 'DocBook-Schema', 'deprecated': False}, 'docbook-xml': {'id': 'DocBook-XML', 'deprecated': False}, 'dotseqn': {'id': 'Dotseqn', 'deprecated': False}, 'drl-1.0': {'id': 'DRL-1.0', 'deprecated': False}, 'drl-1.1': {'id': 'DRL-1.1', 'deprecated': False}, 'dsdp': {'id': 'DSDP', 'deprecated': False}, 'dtoa': {'id': 'dtoa', 'deprecated': False}, 'dvipdfm': {'id': 'dvipdfm', 'deprecated': False}, 'ecl-1.0': {'id': 'ECL-1.0', 'deprecated': False}, 'ecl-2.0': {'id': 'ECL-2.0', 'deprecated': False}, 'ecos-2.0': {'id': 'eCos-2.0', 'deprecated': True}, 'efl-1.0': {'id': 'EFL-1.0', 'deprecated': False}, 'efl-2.0': {'id': 'EFL-2.0', 'deprecated': False}, 'egenix': {'id': 'eGenix', 'deprecated': False}, 'elastic-2.0': {'id': 'Elastic-2.0', 'deprecated': False}, 'entessa': {'id': 'Entessa', 'deprecated': False}, 'epics': {'id': 'EPICS', 'deprecated': False}, 'epl-1.0': {'id': 'EPL-1.0', 'deprecated': False}, 'epl-2.0': {'id': 'EPL-2.0', 'deprecated': False}, 'erlpl-1.1': {'id': 'ErlPL-1.1', 'deprecated': False}, 'etalab-2.0': {'id': 'etalab-2.0', 'deprecated': False}, 'eudatagrid': {'id': 'EUDatagrid', 'deprecated': False}, 'eupl-1.0': {'id': 'EUPL-1.0', 'deprecated': False}, 'eupl-1.1': {'id': 'EUPL-1.1', 'deprecated': False}, 'eupl-1.2': {'id': 'EUPL-1.2', 'deprecated': False}, 'eurosym': {'id': 'Eurosym', 'deprecated': False}, 'fair': {'id': 'Fair', 'deprecated': False}, 'fbm': {'id': 'FBM', 'deprecated': False}, 'fdk-aac': {'id': 'FDK-AAC', 'deprecated': False}, 'ferguson-twofish': {'id': 'Ferguson-Twofish', 'deprecated': False}, 'frameworx-1.0': {'id': 'Frameworx-1.0', 'deprecated': False}, 'freebsd-doc': {'id': 'FreeBSD-DOC', 'deprecated': False}, 'freeimage': {'id': 'FreeImage', 'deprecated': False}, 'fsfap': {'id': 'FSFAP', 'deprecated': False}, 'fsfap-no-warranty-disclaimer': {'id': 'FSFAP-no-warranty-disclaimer', 'deprecated': False}, 'fsful': {'id': 'FSFUL', 'deprecated': False}, 'fsfullr': {'id': 'FSFULLR', 'deprecated': False}, 'fsfullrwd': {'id': 'FSFULLRWD', 'deprecated': False}, 'ftl': {'id': 'FTL', 'deprecated': False}, 'furuseth': {'id': 'Furuseth', 'deprecated': False}, 'fwlw': {'id': 'fwlw', 'deprecated': False}, 'gcr-docs': {'id': 'GCR-docs', 'deprecated': False}, 'gd': {'id': 'GD', 'deprecated': False}, 'gfdl-1.1': {'id': 'GFDL-1.1', 'deprecated': True}, 'gfdl-1.1-invariants-only': {'id': 'GFDL-1.1-invariants-only', 'deprecated': False}, 'gfdl-1.1-invariants-or-later': {'id': 'GFDL-1.1-invariants-or-later', 'deprecated': False}, 'gfdl-1.1-no-invariants-only': {'id': 'GFDL-1.1-no-invariants-only', 'deprecated': False}, 'gfdl-1.1-no-invariants-or-later': {'id': 'GFDL-1.1-no-invariants-or-later', 'deprecated': False}, 'gfdl-1.1-only': {'id': 'GFDL-1.1-only', 'deprecated': False}, 'gfdl-1.1-or-later': {'id': 'GFDL-1.1-or-later', 'deprecated': False}, 'gfdl-1.2': {'id': 'GFDL-1.2', 'deprecated': True}, 'gfdl-1.2-invariants-only': {'id': 'GFDL-1.2-invariants-only', 'deprecated': False}, 'gfdl-1.2-invariants-or-later': {'id': 'GFDL-1.2-invariants-or-later', 'deprecated': False}, 'gfdl-1.2-no-invariants-only': {'id': 'GFDL-1.2-no-invariants-only', 'deprecated': False}, 'gfdl-1.2-no-invariants-or-later': {'id': 'GFDL-1.2-no-invariants-or-later', 'deprecated': False}, 'gfdl-1.2-only': {'id': 'GFDL-1.2-only', 'deprecated': False}, 'gfdl-1.2-or-later': {'id': 'GFDL-1.2-or-later', 'deprecated': False}, 'gfdl-1.3': {'id': 'GFDL-1.3', 'deprecated': True}, 'gfdl-1.3-invariants-only': {'id': 'GFDL-1.3-invariants-only', 'deprecated': False}, 'gfdl-1.3-invariants-or-later': {'id': 'GFDL-1.3-invariants-or-later', 'deprecated': False}, 'gfdl-1.3-no-invariants-only': {'id': 'GFDL-1.3-no-invariants-only', 'deprecated': False}, 'gfdl-1.3-no-invariants-or-later': {'id': 'GFDL-1.3-no-invariants-or-later', 'deprecated': False}, 'gfdl-1.3-only': {'id': 'GFDL-1.3-only', 'deprecated': False}, 'gfdl-1.3-or-later': {'id': 'GFDL-1.3-or-later', 'deprecated': False}, 'giftware': {'id': 'Giftware', 'deprecated': False}, 'gl2ps': {'id': 'GL2PS', 'deprecated': False}, 'glide': {'id': 'Glide', 'deprecated': False}, 'glulxe': {'id': 'Glulxe', 'deprecated': False}, 'glwtpl': {'id': 'GLWTPL', 'deprecated': False}, 'gnuplot': {'id': 'gnuplot', 'deprecated': False}, 'gpl-1.0': {'id': 'GPL-1.0', 'deprecated': True}, 'gpl-1.0+': {'id': 'GPL-1.0+', 'deprecated': True}, 'gpl-1.0-only': {'id': 'GPL-1.0-only', 'deprecated': False}, 'gpl-1.0-or-later': {'id': 'GPL-1.0-or-later', 'deprecated': False}, 'gpl-2.0': {'id': 'GPL-2.0', 'deprecated': True}, 'gpl-2.0+': {'id': 'GPL-2.0+', 'deprecated': True}, 'gpl-2.0-only': {'id': 'GPL-2.0-only', 'deprecated': False}, 'gpl-2.0-or-later': {'id': 'GPL-2.0-or-later', 'deprecated': False}, 'gpl-2.0-with-autoconf-exception': {'id': 'GPL-2.0-with-autoconf-exception', 'deprecated': True}, 'gpl-2.0-with-bison-exception': {'id': 'GPL-2.0-with-bison-exception', 'deprecated': True}, 'gpl-2.0-with-classpath-exception': {'id': 'GPL-2.0-with-classpath-exception', 'deprecated': True}, 'gpl-2.0-with-font-exception': {'id': 'GPL-2.0-with-font-exception', 'deprecated': True}, 'gpl-2.0-with-gcc-exception': {'id': 'GPL-2.0-with-GCC-exception', 'deprecated': True}, 'gpl-3.0': {'id': 'GPL-3.0', 'deprecated': True}, 'gpl-3.0+': {'id': 'GPL-3.0+', 'deprecated': True}, 'gpl-3.0-only': {'id': 'GPL-3.0-only', 'deprecated': False}, 'gpl-3.0-or-later': {'id': 'GPL-3.0-or-later', 'deprecated': False}, 'gpl-3.0-with-autoconf-exception': {'id': 'GPL-3.0-with-autoconf-exception', 'deprecated': True}, 'gpl-3.0-with-gcc-exception': {'id': 'GPL-3.0-with-GCC-exception', 'deprecated': True}, 'graphics-gems': {'id': 'Graphics-Gems', 'deprecated': False}, 'gsoap-1.3b': {'id': 'gSOAP-1.3b', 'deprecated': False}, 'gtkbook': {'id': 'gtkbook', 'deprecated': False}, 'gutmann': {'id': 'Gutmann', 'deprecated': False}, 'haskellreport': {'id': 'HaskellReport', 'deprecated': False}, 'hdparm': {'id': 'hdparm', 'deprecated': False}, 'hidapi': {'id': 'HIDAPI', 'deprecated': False}, 'hippocratic-2.1': {'id': 'Hippocratic-2.1', 'deprecated': False}, 'hp-1986': {'id': 'HP-1986', 'deprecated': False}, 'hp-1989': {'id': 'HP-1989', 'deprecated': False}, 'hpnd': {'id': 'HPND', 'deprecated': False}, 'hpnd-dec': {'id': 'HPND-DEC', 'deprecated': False}, 'hpnd-doc': {'id': 'HPND-doc', 'deprecated': False}, 'hpnd-doc-sell': {'id': 'HPND-doc-sell', 'deprecated': False}, 'hpnd-export-us': {'id': 'HPND-export-US', 'deprecated': False}, 'hpnd-export-us-acknowledgement': {'id': 'HPND-export-US-acknowledgement', 'deprecated': False}, 'hpnd-export-us-modify': {'id': 'HPND-export-US-modify', 'deprecated': False}, 'hpnd-export2-us': {'id': 'HPND-export2-US', 'deprecated': False}, 'hpnd-fenneberg-livingston': {'id': 'HPND-Fenneberg-Livingston', 'deprecated': False}, 'hpnd-inria-imag': {'id': 'HPND-INRIA-IMAG', 'deprecated': False}, 'hpnd-intel': {'id': 'HPND-Intel', 'deprecated': False}, 'hpnd-kevlin-henney': {'id': 'HPND-Kevlin-Henney', 'deprecated': False}, 'hpnd-markus-kuhn': {'id': 'HPND-Markus-Kuhn', 'deprecated': False}, 'hpnd-merchantability-variant': {'id': 'HPND-merchantability-variant', 'deprecated': False}, 'hpnd-mit-disclaimer': {'id': 'HPND-MIT-disclaimer', 'deprecated': False}, 'hpnd-netrek': {'id': 'HPND-Netrek', 'deprecated': False}, 'hpnd-pbmplus': {'id': 'HPND-Pbmplus', 'deprecated': False}, 'hpnd-sell-mit-disclaimer-xserver': {'id': 'HPND-sell-MIT-disclaimer-xserver', 'deprecated': False}, 'hpnd-sell-regexpr': {'id': 'HPND-sell-regexpr', 'deprecated': False}, 'hpnd-sell-variant': {'id': 'HPND-sell-variant', 'deprecated': False}, 'hpnd-sell-variant-mit-disclaimer': {'id': 'HPND-sell-variant-MIT-disclaimer', 'deprecated': False}, 'hpnd-sell-variant-mit-disclaimer-rev': {'id': 'HPND-sell-variant-MIT-disclaimer-rev', 'deprecated': False}, 'hpnd-uc': {'id': 'HPND-UC', 'deprecated': False}, 'hpnd-uc-export-us': {'id': 'HPND-UC-export-US', 'deprecated': False}, 'htmltidy': {'id': 'HTMLTIDY', 'deprecated': False}, 'ibm-pibs': {'id': 'IBM-pibs', 'deprecated': False}, 'icu': {'id': 'ICU', 'deprecated': False}, 'iec-code-components-eula': {'id': 'IEC-Code-Components-EULA', 'deprecated': False}, 'ijg': {'id': 'IJG', 'deprecated': False}, 'ijg-short': {'id': 'IJG-short', 'deprecated': False}, 'imagemagick': {'id': 'ImageMagick', 'deprecated': False}, 'imatix': {'id': 'iMatix', 'deprecated': False}, 'imlib2': {'id': 'Imlib2', 'deprecated': False}, 'info-zip': {'id': 'Info-ZIP', 'deprecated': False}, 'inner-net-2.0': {'id': 'Inner-Net-2.0', 'deprecated': False}, 'intel': {'id': 'Intel', 'deprecated': False}, 'intel-acpi': {'id': 'Intel-ACPI', 'deprecated': False}, 'interbase-1.0': {'id': 'Interbase-1.0', 'deprecated': False}, 'ipa': {'id': 'IPA', 'deprecated': False}, 'ipl-1.0': {'id': 'IPL-1.0', 'deprecated': False}, 'isc': {'id': 'ISC', 'deprecated': False}, 'isc-veillard': {'id': 'ISC-Veillard', 'deprecated': False}, 'jam': {'id': 'Jam', 'deprecated': False}, 'jasper-2.0': {'id': 'JasPer-2.0', 'deprecated': False}, 'jpl-image': {'id': 'JPL-image', 'deprecated': False}, 'jpnic': {'id': 'JPNIC', 'deprecated': False}, 'json': {'id': 'JSON', 'deprecated': False}, 'kastrup': {'id': 'Kastrup', 'deprecated': False}, 'kazlib': {'id': 'Kazlib', 'deprecated': False}, 'knuth-ctan': {'id': 'Knuth-CTAN', 'deprecated': False}, 'lal-1.2': {'id': 'LAL-1.2', 'deprecated': False}, 'lal-1.3': {'id': 'LAL-1.3', 'deprecated': False}, 'latex2e': {'id': 'Latex2e', 'deprecated': False}, 'latex2e-translated-notice': {'id': 'Latex2e-translated-notice', 'deprecated': False}, 'leptonica': {'id': 'Leptonica', 'deprecated': False}, 'lgpl-2.0': {'id': 'LGPL-2.0', 'deprecated': True}, 'lgpl-2.0+': {'id': 'LGPL-2.0+', 'deprecated': True}, 'lgpl-2.0-only': {'id': 'LGPL-2.0-only', 'deprecated': False}, 'lgpl-2.0-or-later': {'id': 'LGPL-2.0-or-later', 'deprecated': False}, 'lgpl-2.1': {'id': 'LGPL-2.1', 'deprecated': True}, 'lgpl-2.1+': {'id': 'LGPL-2.1+', 'deprecated': True}, 'lgpl-2.1-only': {'id': 'LGPL-2.1-only', 'deprecated': False}, 'lgpl-2.1-or-later': {'id': 'LGPL-2.1-or-later', 'deprecated': False}, 'lgpl-3.0': {'id': 'LGPL-3.0', 'deprecated': True}, 'lgpl-3.0+': {'id': 'LGPL-3.0+', 'deprecated': True}, 'lgpl-3.0-only': {'id': 'LGPL-3.0-only', 'deprecated': False}, 'lgpl-3.0-or-later': {'id': 'LGPL-3.0-or-later', 'deprecated': False}, 'lgpllr': {'id': 'LGPLLR', 'deprecated': False}, 'libpng': {'id': 'Libpng', 'deprecated': False}, 'libpng-2.0': {'id': 'libpng-2.0', 'deprecated': False}, 'libselinux-1.0': {'id': 'libselinux-1.0', 'deprecated': False}, 'libtiff': {'id': 'libtiff', 'deprecated': False}, 'libutil-david-nugent': {'id': 'libutil-David-Nugent', 'deprecated': False}, 'liliq-p-1.1': {'id': 'LiLiQ-P-1.1', 'deprecated': False}, 'liliq-r-1.1': {'id': 'LiLiQ-R-1.1', 'deprecated': False}, 'liliq-rplus-1.1': {'id': 'LiLiQ-Rplus-1.1', 'deprecated': False}, 'linux-man-pages-1-para': {'id': 'Linux-man-pages-1-para', 'deprecated': False}, 'linux-man-pages-copyleft': {'id': 'Linux-man-pages-copyleft', 'deprecated': False}, 'linux-man-pages-copyleft-2-para': {'id': 'Linux-man-pages-copyleft-2-para', 'deprecated': False}, 'linux-man-pages-copyleft-var': {'id': 'Linux-man-pages-copyleft-var', 'deprecated': False}, 'linux-openib': {'id': 'Linux-OpenIB', 'deprecated': False}, 'loop': {'id': 'LOOP', 'deprecated': False}, 'lpd-document': {'id': 'LPD-document', 'deprecated': False}, 'lpl-1.0': {'id': 'LPL-1.0', 'deprecated': False}, 'lpl-1.02': {'id': 'LPL-1.02', 'deprecated': False}, 'lppl-1.0': {'id': 'LPPL-1.0', 'deprecated': False}, 'lppl-1.1': {'id': 'LPPL-1.1', 'deprecated': False}, 'lppl-1.2': {'id': 'LPPL-1.2', 'deprecated': False}, 'lppl-1.3a': {'id': 'LPPL-1.3a', 'deprecated': False}, 'lppl-1.3c': {'id': 'LPPL-1.3c', 'deprecated': False}, 'lsof': {'id': 'lsof', 'deprecated': False}, 'lucida-bitmap-fonts': {'id': 'Lucida-Bitmap-Fonts', 'deprecated': False}, 'lzma-sdk-9.11-to-9.20': {'id': 'LZMA-SDK-9.11-to-9.20', 'deprecated': False}, 'lzma-sdk-9.22': {'id': 'LZMA-SDK-9.22', 'deprecated': False}, 'mackerras-3-clause': {'id': 'Mackerras-3-Clause', 'deprecated': False}, 'mackerras-3-clause-acknowledgment': {'id': 'Mackerras-3-Clause-acknowledgment', 'deprecated': False}, 'magaz': {'id': 'magaz', 'deprecated': False}, 'mailprio': {'id': 'mailprio', 'deprecated': False}, 'makeindex': {'id': 'MakeIndex', 'deprecated': False}, 'martin-birgmeier': {'id': 'Martin-Birgmeier', 'deprecated': False}, 'mcphee-slideshow': {'id': 'McPhee-slideshow', 'deprecated': False}, 'metamail': {'id': 'metamail', 'deprecated': False}, 'minpack': {'id': 'Minpack', 'deprecated': False}, 'miros': {'id': 'MirOS', 'deprecated': False}, 'mit': {'id': 'MIT', 'deprecated': False}, 'mit-0': {'id': 'MIT-0', 'deprecated': False}, 'mit-advertising': {'id': 'MIT-advertising', 'deprecated': False}, 'mit-cmu': {'id': 'MIT-CMU', 'deprecated': False}, 'mit-enna': {'id': 'MIT-enna', 'deprecated': False}, 'mit-feh': {'id': 'MIT-feh', 'deprecated': False}, 'mit-festival': {'id': 'MIT-Festival', 'deprecated': False}, 'mit-khronos-old': {'id': 'MIT-Khronos-old', 'deprecated': False}, 'mit-modern-variant': {'id': 'MIT-Modern-Variant', 'deprecated': False}, 'mit-open-group': {'id': 'MIT-open-group', 'deprecated': False}, 'mit-testregex': {'id': 'MIT-testregex', 'deprecated': False}, 'mit-wu': {'id': 'MIT-Wu', 'deprecated': False}, 'mitnfa': {'id': 'MITNFA', 'deprecated': False}, 'mmixware': {'id': 'MMIXware', 'deprecated': False}, 'motosoto': {'id': 'Motosoto', 'deprecated': False}, 'mpeg-ssg': {'id': 'MPEG-SSG', 'deprecated': False}, 'mpi-permissive': {'id': 'mpi-permissive', 'deprecated': False}, 'mpich2': {'id': 'mpich2', 'deprecated': False}, 'mpl-1.0': {'id': 'MPL-1.0', 'deprecated': False}, 'mpl-1.1': {'id': 'MPL-1.1', 'deprecated': False}, 'mpl-2.0': {'id': 'MPL-2.0', 'deprecated': False}, 'mpl-2.0-no-copyleft-exception': {'id': 'MPL-2.0-no-copyleft-exception', 'deprecated': False}, 'mplus': {'id': 'mplus', 'deprecated': False}, 'ms-lpl': {'id': 'MS-LPL', 'deprecated': False}, 'ms-pl': {'id': 'MS-PL', 'deprecated': False}, 'ms-rl': {'id': 'MS-RL', 'deprecated': False}, 'mtll': {'id': 'MTLL', 'deprecated': False}, 'mulanpsl-1.0': {'id': 'MulanPSL-1.0', 'deprecated': False}, 'mulanpsl-2.0': {'id': 'MulanPSL-2.0', 'deprecated': False}, 'multics': {'id': 'Multics', 'deprecated': False}, 'mup': {'id': 'Mup', 'deprecated': False}, 'naist-2003': {'id': 'NAIST-2003', 'deprecated': False}, 'nasa-1.3': {'id': 'NASA-1.3', 'deprecated': False}, 'naumen': {'id': 'Naumen', 'deprecated': False}, 'nbpl-1.0': {'id': 'NBPL-1.0', 'deprecated': False}, 'ncbi-pd': {'id': 'NCBI-PD', 'deprecated': False}, 'ncgl-uk-2.0': {'id': 'NCGL-UK-2.0', 'deprecated': False}, 'ncl': {'id': 'NCL', 'deprecated': False}, 'ncsa': {'id': 'NCSA', 'deprecated': False}, 'net-snmp': {'id': 'Net-SNMP', 'deprecated': True}, 'netcdf': {'id': 'NetCDF', 'deprecated': False}, 'newsletr': {'id': 'Newsletr', 'deprecated': False}, 'ngpl': {'id': 'NGPL', 'deprecated': False}, 'nicta-1.0': {'id': 'NICTA-1.0', 'deprecated': False}, 'nist-pd': {'id': 'NIST-PD', 'deprecated': False}, 'nist-pd-fallback': {'id': 'NIST-PD-fallback', 'deprecated': False}, 'nist-software': {'id': 'NIST-Software', 'deprecated': False}, 'nlod-1.0': {'id': 'NLOD-1.0', 'deprecated': False}, 'nlod-2.0': {'id': 'NLOD-2.0', 'deprecated': False}, 'nlpl': {'id': 'NLPL', 'deprecated': False}, 'nokia': {'id': 'Nokia', 'deprecated': False}, 'nosl': {'id': 'NOSL', 'deprecated': False}, 'noweb': {'id': 'Noweb', 'deprecated': False}, 'npl-1.0': {'id': 'NPL-1.0', 'deprecated': False}, 'npl-1.1': {'id': 'NPL-1.1', 'deprecated': False}, 'nposl-3.0': {'id': 'NPOSL-3.0', 'deprecated': False}, 'nrl': {'id': 'NRL', 'deprecated': False}, 'ntp': {'id': 'NTP', 'deprecated': False}, 'ntp-0': {'id': 'NTP-0', 'deprecated': False}, 'nunit': {'id': 'Nunit', 'deprecated': True}, 'o-uda-1.0': {'id': 'O-UDA-1.0', 'deprecated': False}, 'oar': {'id': 'OAR', 'deprecated': False}, 'occt-pl': {'id': 'OCCT-PL', 'deprecated': False}, 'oclc-2.0': {'id': 'OCLC-2.0', 'deprecated': False}, 'odbl-1.0': {'id': 'ODbL-1.0', 'deprecated': False}, 'odc-by-1.0': {'id': 'ODC-By-1.0', 'deprecated': False}, 'offis': {'id': 'OFFIS', 'deprecated': False}, 'ofl-1.0': {'id': 'OFL-1.0', 'deprecated': False}, 'ofl-1.0-no-rfn': {'id': 'OFL-1.0-no-RFN', 'deprecated': False}, 'ofl-1.0-rfn': {'id': 'OFL-1.0-RFN', 'deprecated': False}, 'ofl-1.1': {'id': 'OFL-1.1', 'deprecated': False}, 'ofl-1.1-no-rfn': {'id': 'OFL-1.1-no-RFN', 'deprecated': False}, 'ofl-1.1-rfn': {'id': 'OFL-1.1-RFN', 'deprecated': False}, 'ogc-1.0': {'id': 'OGC-1.0', 'deprecated': False}, 'ogdl-taiwan-1.0': {'id': 'OGDL-Taiwan-1.0', 'deprecated': False}, 'ogl-canada-2.0': {'id': 'OGL-Canada-2.0', 'deprecated': False}, 'ogl-uk-1.0': {'id': 'OGL-UK-1.0', 'deprecated': False}, 'ogl-uk-2.0': {'id': 'OGL-UK-2.0', 'deprecated': False}, 'ogl-uk-3.0': {'id': 'OGL-UK-3.0', 'deprecated': False}, 'ogtsl': {'id': 'OGTSL', 'deprecated': False}, 'oldap-1.1': {'id': 'OLDAP-1.1', 'deprecated': False}, 'oldap-1.2': {'id': 'OLDAP-1.2', 'deprecated': False}, 'oldap-1.3': {'id': 'OLDAP-1.3', 'deprecated': False}, 'oldap-1.4': {'id': 'OLDAP-1.4', 'deprecated': False}, 'oldap-2.0': {'id': 'OLDAP-2.0', 'deprecated': False}, 'oldap-2.0.1': {'id': 'OLDAP-2.0.1', 'deprecated': False}, 'oldap-2.1': {'id': 'OLDAP-2.1', 'deprecated': False}, 'oldap-2.2': {'id': 'OLDAP-2.2', 'deprecated': False}, 'oldap-2.2.1': {'id': 'OLDAP-2.2.1', 'deprecated': False}, 'oldap-2.2.2': {'id': 'OLDAP-2.2.2', 'deprecated': False}, 'oldap-2.3': {'id': 'OLDAP-2.3', 'deprecated': False}, 'oldap-2.4': {'id': 'OLDAP-2.4', 'deprecated': False}, 'oldap-2.5': {'id': 'OLDAP-2.5', 'deprecated': False}, 'oldap-2.6': {'id': 'OLDAP-2.6', 'deprecated': False}, 'oldap-2.7': {'id': 'OLDAP-2.7', 'deprecated': False}, 'oldap-2.8': {'id': 'OLDAP-2.8', 'deprecated': False}, 'olfl-1.3': {'id': 'OLFL-1.3', 'deprecated': False}, 'oml': {'id': 'OML', 'deprecated': False}, 'openpbs-2.3': {'id': 'OpenPBS-2.3', 'deprecated': False}, 'openssl': {'id': 'OpenSSL', 'deprecated': False}, 'openssl-standalone': {'id': 'OpenSSL-standalone', 'deprecated': False}, 'openvision': {'id': 'OpenVision', 'deprecated': False}, 'opl-1.0': {'id': 'OPL-1.0', 'deprecated': False}, 'opl-uk-3.0': {'id': 'OPL-UK-3.0', 'deprecated': False}, 'opubl-1.0': {'id': 'OPUBL-1.0', 'deprecated': False}, 'oset-pl-2.1': {'id': 'OSET-PL-2.1', 'deprecated': False}, 'osl-1.0': {'id': 'OSL-1.0', 'deprecated': False}, 'osl-1.1': {'id': 'OSL-1.1', 'deprecated': False}, 'osl-2.0': {'id': 'OSL-2.0', 'deprecated': False}, 'osl-2.1': {'id': 'OSL-2.1', 'deprecated': False}, 'osl-3.0': {'id': 'OSL-3.0', 'deprecated': False}, 'padl': {'id': 'PADL', 'deprecated': False}, 'parity-6.0.0': {'id': 'Parity-6.0.0', 'deprecated': False}, 'parity-7.0.0': {'id': 'Parity-7.0.0', 'deprecated': False}, 'pddl-1.0': {'id': 'PDDL-1.0', 'deprecated': False}, 'php-3.0': {'id': 'PHP-3.0', 'deprecated': False}, 'php-3.01': {'id': 'PHP-3.01', 'deprecated': False}, 'pixar': {'id': 'Pixar', 'deprecated': False}, 'pkgconf': {'id': 'pkgconf', 'deprecated': False}, 'plexus': {'id': 'Plexus', 'deprecated': False}, 'pnmstitch': {'id': 'pnmstitch', 'deprecated': False}, 'polyform-noncommercial-1.0.0': {'id': 'PolyForm-Noncommercial-1.0.0', 'deprecated': False}, 'polyform-small-business-1.0.0': {'id': 'PolyForm-Small-Business-1.0.0', 'deprecated': False}, 'postgresql': {'id': 'PostgreSQL', 'deprecated': False}, 'ppl': {'id': 'PPL', 'deprecated': False}, 'psf-2.0': {'id': 'PSF-2.0', 'deprecated': False}, 'psfrag': {'id': 'psfrag', 'deprecated': False}, 'psutils': {'id': 'psutils', 'deprecated': False}, 'python-2.0': {'id': 'Python-2.0', 'deprecated': False}, 'python-2.0.1': {'id': 'Python-2.0.1', 'deprecated': False}, 'python-ldap': {'id': 'python-ldap', 'deprecated': False}, 'qhull': {'id': 'Qhull', 'deprecated': False}, 'qpl-1.0': {'id': 'QPL-1.0', 'deprecated': False}, 'qpl-1.0-inria-2004': {'id': 'QPL-1.0-INRIA-2004', 'deprecated': False}, 'radvd': {'id': 'radvd', 'deprecated': False}, 'rdisc': {'id': 'Rdisc', 'deprecated': False}, 'rhecos-1.1': {'id': 'RHeCos-1.1', 'deprecated': False}, 'rpl-1.1': {'id': 'RPL-1.1', 'deprecated': False}, 'rpl-1.5': {'id': 'RPL-1.5', 'deprecated': False}, 'rpsl-1.0': {'id': 'RPSL-1.0', 'deprecated': False}, 'rsa-md': {'id': 'RSA-MD', 'deprecated': False}, 'rscpl': {'id': 'RSCPL', 'deprecated': False}, 'ruby': {'id': 'Ruby', 'deprecated': False}, 'ruby-pty': {'id': 'Ruby-pty', 'deprecated': False}, 'sax-pd': {'id': 'SAX-PD', 'deprecated': False}, 'sax-pd-2.0': {'id': 'SAX-PD-2.0', 'deprecated': False}, 'saxpath': {'id': 'Saxpath', 'deprecated': False}, 'scea': {'id': 'SCEA', 'deprecated': False}, 'schemereport': {'id': 'SchemeReport', 'deprecated': False}, 'sendmail': {'id': 'Sendmail', 'deprecated': False}, 'sendmail-8.23': {'id': 'Sendmail-8.23', 'deprecated': False}, 'sgi-b-1.0': {'id': 'SGI-B-1.0', 'deprecated': False}, 'sgi-b-1.1': {'id': 'SGI-B-1.1', 'deprecated': False}, 'sgi-b-2.0': {'id': 'SGI-B-2.0', 'deprecated': False}, 'sgi-opengl': {'id': 'SGI-OpenGL', 'deprecated': False}, 'sgp4': {'id': 'SGP4', 'deprecated': False}, 'shl-0.5': {'id': 'SHL-0.5', 'deprecated': False}, 'shl-0.51': {'id': 'SHL-0.51', 'deprecated': False}, 'simpl-2.0': {'id': 'SimPL-2.0', 'deprecated': False}, 'sissl': {'id': 'SISSL', 'deprecated': False}, 'sissl-1.2': {'id': 'SISSL-1.2', 'deprecated': False}, 'sl': {'id': 'SL', 'deprecated': False}, 'sleepycat': {'id': 'Sleepycat', 'deprecated': False}, 'smlnj': {'id': 'SMLNJ', 'deprecated': False}, 'smppl': {'id': 'SMPPL', 'deprecated': False}, 'snia': {'id': 'SNIA', 'deprecated': False}, 'snprintf': {'id': 'snprintf', 'deprecated': False}, 'softsurfer': {'id': 'softSurfer', 'deprecated': False}, 'soundex': {'id': 'Soundex', 'deprecated': False}, 'spencer-86': {'id': 'Spencer-86', 'deprecated': False}, 'spencer-94': {'id': 'Spencer-94', 'deprecated': False}, 'spencer-99': {'id': 'Spencer-99', 'deprecated': False}, 'spl-1.0': {'id': 'SPL-1.0', 'deprecated': False}, 'ssh-keyscan': {'id': 'ssh-keyscan', 'deprecated': False}, 'ssh-openssh': {'id': 'SSH-OpenSSH', 'deprecated': False}, 'ssh-short': {'id': 'SSH-short', 'deprecated': False}, 'ssleay-standalone': {'id': 'SSLeay-standalone', 'deprecated': False}, 'sspl-1.0': {'id': 'SSPL-1.0', 'deprecated': False}, 'standardml-nj': {'id': 'StandardML-NJ', 'deprecated': True}, 'sugarcrm-1.1.3': {'id': 'SugarCRM-1.1.3', 'deprecated': False}, 'sun-ppp': {'id': 'Sun-PPP', 'deprecated': False}, 'sun-ppp-2000': {'id': 'Sun-PPP-2000', 'deprecated': False}, 'sunpro': {'id': 'SunPro', 'deprecated': False}, 'swl': {'id': 'SWL', 'deprecated': False}, 'swrule': {'id': 'swrule', 'deprecated': False}, 'symlinks': {'id': 'Symlinks', 'deprecated': False}, 'tapr-ohl-1.0': {'id': 'TAPR-OHL-1.0', 'deprecated': False}, 'tcl': {'id': 'TCL', 'deprecated': False}, 'tcp-wrappers': {'id': 'TCP-wrappers', 'deprecated': False}, 'termreadkey': {'id': 'TermReadKey', 'deprecated': False}, 'tgppl-1.0': {'id': 'TGPPL-1.0', 'deprecated': False}, 'threeparttable': {'id': 'threeparttable', 'deprecated': False}, 'tmate': {'id': 'TMate', 'deprecated': False}, 'torque-1.1': {'id': 'TORQUE-1.1', 'deprecated': False}, 'tosl': {'id': 'TOSL', 'deprecated': False}, 'tpdl': {'id': 'TPDL', 'deprecated': False}, 'tpl-1.0': {'id': 'TPL-1.0', 'deprecated': False}, 'ttwl': {'id': 'TTWL', 'deprecated': False}, 'ttyp0': {'id': 'TTYP0', 'deprecated': False}, 'tu-berlin-1.0': {'id': 'TU-Berlin-1.0', 'deprecated': False}, 'tu-berlin-2.0': {'id': 'TU-Berlin-2.0', 'deprecated': False}, 'ubuntu-font-1.0': {'id': 'Ubuntu-font-1.0', 'deprecated': False}, 'ucar': {'id': 'UCAR', 'deprecated': False}, 'ucl-1.0': {'id': 'UCL-1.0', 'deprecated': False}, 'ulem': {'id': 'ulem', 'deprecated': False}, 'umich-merit': {'id': 'UMich-Merit', 'deprecated': False}, 'unicode-3.0': {'id': 'Unicode-3.0', 'deprecated': False}, 'unicode-dfs-2015': {'id': 'Unicode-DFS-2015', 'deprecated': False}, 'unicode-dfs-2016': {'id': 'Unicode-DFS-2016', 'deprecated': False}, 'unicode-tou': {'id': 'Unicode-TOU', 'deprecated': False}, 'unixcrypt': {'id': 'UnixCrypt', 'deprecated': False}, 'unlicense': {'id': 'Unlicense', 'deprecated': False}, 'upl-1.0': {'id': 'UPL-1.0', 'deprecated': False}, 'urt-rle': {'id': 'URT-RLE', 'deprecated': False}, 'vim': {'id': 'Vim', 'deprecated': False}, 'vostrom': {'id': 'VOSTROM', 'deprecated': False}, 'vsl-1.0': {'id': 'VSL-1.0', 'deprecated': False}, 'w3c': {'id': 'W3C', 'deprecated': False}, 'w3c-19980720': {'id': 'W3C-19980720', 'deprecated': False}, 'w3c-20150513': {'id': 'W3C-20150513', 'deprecated': False}, 'w3m': {'id': 'w3m', 'deprecated': False}, 'watcom-1.0': {'id': 'Watcom-1.0', 'deprecated': False}, 'widget-workshop': {'id': 'Widget-Workshop', 'deprecated': False}, 'wsuipa': {'id': 'Wsuipa', 'deprecated': False}, 'wtfpl': {'id': 'WTFPL', 'deprecated': False}, 'wxwindows': {'id': 'wxWindows', 'deprecated': True}, 'x11': {'id': 'X11', 'deprecated': False}, 'x11-distribute-modifications-variant': {'id': 'X11-distribute-modifications-variant', 'deprecated': False}, 'x11-swapped': {'id': 'X11-swapped', 'deprecated': False}, 'xdebug-1.03': {'id': 'Xdebug-1.03', 'deprecated': False}, 'xerox': {'id': 'Xerox', 'deprecated': False}, 'xfig': {'id': 'Xfig', 'deprecated': False}, 'xfree86-1.1': {'id': 'XFree86-1.1', 'deprecated': False}, 'xinetd': {'id': 'xinetd', 'deprecated': False}, 'xkeyboard-config-zinoviev': {'id': 'xkeyboard-config-Zinoviev', 'deprecated': False}, 'xlock': {'id': 'xlock', 'deprecated': False}, 'xnet': {'id': 'Xnet', 'deprecated': False}, 'xpp': {'id': 'xpp', 'deprecated': False}, 'xskat': {'id': 'XSkat', 'deprecated': False}, 'xzoom': {'id': 'xzoom', 'deprecated': False}, 'ypl-1.0': {'id': 'YPL-1.0', 'deprecated': False}, 'ypl-1.1': {'id': 'YPL-1.1', 'deprecated': False}, 'zed': {'id': 'Zed', 'deprecated': False}, 'zeeff': {'id': 'Zeeff', 'deprecated': False}, 'zend-2.0': {'id': 'Zend-2.0', 'deprecated': False}, 'zimbra-1.3': {'id': 'Zimbra-1.3', 'deprecated': False}, 'zimbra-1.4': {'id': 'Zimbra-1.4', 'deprecated': False}, 'zlib': {'id': 'Zlib', 'deprecated': False}, 'zlib-acknowledgement': {'id': 'zlib-acknowledgement', 'deprecated': False}, 'zpl-1.1': {'id': 'ZPL-1.1', 'deprecated': False}, 'zpl-2.0': {'id': 'ZPL-2.0', 'deprecated': False}, 'zpl-2.1': {'id': 'ZPL-2.1', 'deprecated': False}, } EXCEPTIONS: dict[str, SPDXException] = { '389-exception': {'id': '389-exception', 'deprecated': False}, 'asterisk-exception': {'id': 'Asterisk-exception', 'deprecated': False}, 'asterisk-linking-protocols-exception': {'id': 'Asterisk-linking-protocols-exception', 'deprecated': False}, 'autoconf-exception-2.0': {'id': 'Autoconf-exception-2.0', 'deprecated': False}, 'autoconf-exception-3.0': {'id': 'Autoconf-exception-3.0', 'deprecated': False}, 'autoconf-exception-generic': {'id': 'Autoconf-exception-generic', 'deprecated': False}, 'autoconf-exception-generic-3.0': {'id': 'Autoconf-exception-generic-3.0', 'deprecated': False}, 'autoconf-exception-macro': {'id': 'Autoconf-exception-macro', 'deprecated': False}, 'bison-exception-1.24': {'id': 'Bison-exception-1.24', 'deprecated': False}, 'bison-exception-2.2': {'id': 'Bison-exception-2.2', 'deprecated': False}, 'bootloader-exception': {'id': 'Bootloader-exception', 'deprecated': False}, 'classpath-exception-2.0': {'id': 'Classpath-exception-2.0', 'deprecated': False}, 'clisp-exception-2.0': {'id': 'CLISP-exception-2.0', 'deprecated': False}, 'cryptsetup-openssl-exception': {'id': 'cryptsetup-OpenSSL-exception', 'deprecated': False}, 'digirule-foss-exception': {'id': 'DigiRule-FOSS-exception', 'deprecated': False}, 'ecos-exception-2.0': {'id': 'eCos-exception-2.0', 'deprecated': False}, 'erlang-otp-linking-exception': {'id': 'erlang-otp-linking-exception', 'deprecated': False}, 'fawkes-runtime-exception': {'id': 'Fawkes-Runtime-exception', 'deprecated': False}, 'fltk-exception': {'id': 'FLTK-exception', 'deprecated': False}, 'fmt-exception': {'id': 'fmt-exception', 'deprecated': False}, 'font-exception-2.0': {'id': 'Font-exception-2.0', 'deprecated': False}, 'freertos-exception-2.0': {'id': 'freertos-exception-2.0', 'deprecated': False}, 'gcc-exception-2.0': {'id': 'GCC-exception-2.0', 'deprecated': False}, 'gcc-exception-2.0-note': {'id': 'GCC-exception-2.0-note', 'deprecated': False}, 'gcc-exception-3.1': {'id': 'GCC-exception-3.1', 'deprecated': False}, 'gmsh-exception': {'id': 'Gmsh-exception', 'deprecated': False}, 'gnat-exception': {'id': 'GNAT-exception', 'deprecated': False}, 'gnome-examples-exception': {'id': 'GNOME-examples-exception', 'deprecated': False}, 'gnu-compiler-exception': {'id': 'GNU-compiler-exception', 'deprecated': False}, 'gnu-javamail-exception': {'id': 'gnu-javamail-exception', 'deprecated': False}, 'gpl-3.0-interface-exception': {'id': 'GPL-3.0-interface-exception', 'deprecated': False}, 'gpl-3.0-linking-exception': {'id': 'GPL-3.0-linking-exception', 'deprecated': False}, 'gpl-3.0-linking-source-exception': {'id': 'GPL-3.0-linking-source-exception', 'deprecated': False}, 'gpl-cc-1.0': {'id': 'GPL-CC-1.0', 'deprecated': False}, 'gstreamer-exception-2005': {'id': 'GStreamer-exception-2005', 'deprecated': False}, 'gstreamer-exception-2008': {'id': 'GStreamer-exception-2008', 'deprecated': False}, 'i2p-gpl-java-exception': {'id': 'i2p-gpl-java-exception', 'deprecated': False}, 'kicad-libraries-exception': {'id': 'KiCad-libraries-exception', 'deprecated': False}, 'lgpl-3.0-linking-exception': {'id': 'LGPL-3.0-linking-exception', 'deprecated': False}, 'libpri-openh323-exception': {'id': 'libpri-OpenH323-exception', 'deprecated': False}, 'libtool-exception': {'id': 'Libtool-exception', 'deprecated': False}, 'linux-syscall-note': {'id': 'Linux-syscall-note', 'deprecated': False}, 'llgpl': {'id': 'LLGPL', 'deprecated': False}, 'llvm-exception': {'id': 'LLVM-exception', 'deprecated': False}, 'lzma-exception': {'id': 'LZMA-exception', 'deprecated': False}, 'mif-exception': {'id': 'mif-exception', 'deprecated': False}, 'nokia-qt-exception-1.1': {'id': 'Nokia-Qt-exception-1.1', 'deprecated': True}, 'ocaml-lgpl-linking-exception': {'id': 'OCaml-LGPL-linking-exception', 'deprecated': False}, 'occt-exception-1.0': {'id': 'OCCT-exception-1.0', 'deprecated': False}, 'openjdk-assembly-exception-1.0': {'id': 'OpenJDK-assembly-exception-1.0', 'deprecated': False}, 'openvpn-openssl-exception': {'id': 'openvpn-openssl-exception', 'deprecated': False}, 'pcre2-exception': {'id': 'PCRE2-exception', 'deprecated': False}, 'ps-or-pdf-font-exception-20170817': {'id': 'PS-or-PDF-font-exception-20170817', 'deprecated': False}, 'qpl-1.0-inria-2004-exception': {'id': 'QPL-1.0-INRIA-2004-exception', 'deprecated': False}, 'qt-gpl-exception-1.0': {'id': 'Qt-GPL-exception-1.0', 'deprecated': False}, 'qt-lgpl-exception-1.1': {'id': 'Qt-LGPL-exception-1.1', 'deprecated': False}, 'qwt-exception-1.0': {'id': 'Qwt-exception-1.0', 'deprecated': False}, 'romic-exception': {'id': 'romic-exception', 'deprecated': False}, 'rrdtool-floss-exception-2.0': {'id': 'RRDtool-FLOSS-exception-2.0', 'deprecated': False}, 'sane-exception': {'id': 'SANE-exception', 'deprecated': False}, 'shl-2.0': {'id': 'SHL-2.0', 'deprecated': False}, 'shl-2.1': {'id': 'SHL-2.1', 'deprecated': False}, 'stunnel-exception': {'id': 'stunnel-exception', 'deprecated': False}, 'swi-exception': {'id': 'SWI-exception', 'deprecated': False}, 'swift-exception': {'id': 'Swift-exception', 'deprecated': False}, 'texinfo-exception': {'id': 'Texinfo-exception', 'deprecated': False}, 'u-boot-exception-2.0': {'id': 'u-boot-exception-2.0', 'deprecated': False}, 'ubdl-exception': {'id': 'UBDL-exception', 'deprecated': False}, 'universal-foss-exception-1.0': {'id': 'Universal-FOSS-exception-1.0', 'deprecated': False}, 'vsftpd-openssl-exception': {'id': 'vsftpd-openssl-exception', 'deprecated': False}, 'wxwindows-exception-3.1': {'id': 'WxWindows-exception-3.1', 'deprecated': False}, 'x11vnc-openssl-exception': {'id': 'x11vnc-openssl-exception', 'deprecated': False}, } licenses/__init__.py 0000644 00000013123 15030064363 0010462 0 ustar 00 ####################################################################################### # # Adapted from: # https://github.com/pypa/hatch/blob/5352e44/backend/src/hatchling/licenses/parse.py # # MIT License # # Copyright (c) 2017-present Ofek Lev <oss@ofek.dev> # # Permission is hereby granted, free of charge, to any person obtaining a copy of this # software and associated documentation files (the "Software"), to deal in the Software # without restriction, including without limitation the rights to use, copy, modify, # merge, publish, distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to the following # conditions: # # The above copyright notice and this permission notice shall be included in all copies # or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, # INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A # PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF # CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE # OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # # With additional allowance of arbitrary `LicenseRef-` identifiers, not just # `LicenseRef-Public-Domain` and `LicenseRef-Proprietary`. # ####################################################################################### from __future__ import annotations import re from typing import NewType, cast from packaging.licenses._spdx import EXCEPTIONS, LICENSES __all__ = [ "InvalidLicenseExpression", "NormalizedLicenseExpression", "canonicalize_license_expression", ] license_ref_allowed = re.compile("^[A-Za-z0-9.-]*$") NormalizedLicenseExpression = NewType("NormalizedLicenseExpression", str) class InvalidLicenseExpression(ValueError): """Raised when a license-expression string is invalid >>> canonicalize_license_expression("invalid") Traceback (most recent call last): ... packaging.licenses.InvalidLicenseExpression: Invalid license expression: 'invalid' """ def canonicalize_license_expression( raw_license_expression: str, ) -> NormalizedLicenseExpression: if not raw_license_expression: message = f"Invalid license expression: {raw_license_expression!r}" raise InvalidLicenseExpression(message) # Pad any parentheses so tokenization can be achieved by merely splitting on # whitespace. license_expression = raw_license_expression.replace("(", " ( ").replace(")", " ) ") licenseref_prefix = "LicenseRef-" license_refs = { ref.lower(): "LicenseRef-" + ref[len(licenseref_prefix) :] for ref in license_expression.split() if ref.lower().startswith(licenseref_prefix.lower()) } # Normalize to lower case so we can look up licenses/exceptions # and so boolean operators are Python-compatible. license_expression = license_expression.lower() tokens = license_expression.split() # Rather than implementing boolean logic, we create an expression that Python can # parse. Everything that is not involved with the grammar itself is treated as # `False` and the expression should evaluate as such. python_tokens = [] for token in tokens: if token not in {"or", "and", "with", "(", ")"}: python_tokens.append("False") elif token == "with": python_tokens.append("or") elif token == "(" and python_tokens and python_tokens[-1] not in {"or", "and"}: message = f"Invalid license expression: {raw_license_expression!r}" raise InvalidLicenseExpression(message) else: python_tokens.append(token) python_expression = " ".join(python_tokens) try: invalid = eval(python_expression, globals(), locals()) except Exception: invalid = True if invalid is not False: message = f"Invalid license expression: {raw_license_expression!r}" raise InvalidLicenseExpression(message) from None # Take a final pass to check for unknown licenses/exceptions. normalized_tokens = [] for token in tokens: if token in {"or", "and", "with", "(", ")"}: normalized_tokens.append(token.upper()) continue if normalized_tokens and normalized_tokens[-1] == "WITH": if token not in EXCEPTIONS: message = f"Unknown license exception: {token!r}" raise InvalidLicenseExpression(message) normalized_tokens.append(EXCEPTIONS[token]["id"]) else: if token.endswith("+"): final_token = token[:-1] suffix = "+" else: final_token = token suffix = "" if final_token.startswith("licenseref-"): if not license_ref_allowed.match(final_token): message = f"Invalid licenseref: {final_token!r}" raise InvalidLicenseExpression(message) normalized_tokens.append(license_refs[final_token] + suffix) else: if final_token not in LICENSES: message = f"Unknown license: {final_token!r}" raise InvalidLicenseExpression(message) normalized_tokens.append(LICENSES[final_token]["id"] + suffix) normalized_expression = " ".join(normalized_tokens) return cast( NormalizedLicenseExpression, normalized_expression.replace("( ", "(").replace(" )", ")"), ) metadata.py 0000644 00000103663 15030064363 0006707 0 ustar 00 from __future__ import annotations import email.feedparser import email.header import email.message import email.parser import email.policy import pathlib import sys import typing from typing import ( Any, Callable, Generic, Literal, TypedDict, cast, ) from . import licenses, requirements, specifiers, utils from . import version as version_module from .licenses import NormalizedLicenseExpression T = typing.TypeVar("T") if sys.version_info >= (3, 11): # pragma: no cover ExceptionGroup = ExceptionGroup else: # pragma: no cover class ExceptionGroup(Exception): """A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11. If :external:exc:`ExceptionGroup` is already defined by Python itself, that version is used instead. """ message: str exceptions: list[Exception] def __init__(self, message: str, exceptions: list[Exception]) -> None: self.message = message self.exceptions = exceptions def __repr__(self) -> str: return f"{self.__class__.__name__}({self.message!r}, {self.exceptions!r})" class InvalidMetadata(ValueError): """A metadata field contains invalid data.""" field: str """The name of the field that contains invalid data.""" def __init__(self, field: str, message: str) -> None: self.field = field super().__init__(message) # The RawMetadata class attempts to make as few assumptions about the underlying # serialization formats as possible. The idea is that as long as a serialization # formats offer some very basic primitives in *some* way then we can support # serializing to and from that format. class RawMetadata(TypedDict, total=False): """A dictionary of raw core metadata. Each field in core metadata maps to a key of this dictionary (when data is provided). The key is lower-case and underscores are used instead of dashes compared to the equivalent core metadata field. Any core metadata field that can be specified multiple times or can hold multiple values in a single field have a key with a plural name. See :class:`Metadata` whose attributes match the keys of this dictionary. Core metadata fields that can be specified multiple times are stored as a list or dict depending on which is appropriate for the field. Any fields which hold multiple values in a single field are stored as a list. """ # Metadata 1.0 - PEP 241 metadata_version: str name: str version: str platforms: list[str] summary: str description: str keywords: list[str] home_page: str author: str author_email: str license: str # Metadata 1.1 - PEP 314 supported_platforms: list[str] download_url: str classifiers: list[str] requires: list[str] provides: list[str] obsoletes: list[str] # Metadata 1.2 - PEP 345 maintainer: str maintainer_email: str requires_dist: list[str] provides_dist: list[str] obsoletes_dist: list[str] requires_python: str requires_external: list[str] project_urls: dict[str, str] # Metadata 2.0 # PEP 426 attempted to completely revamp the metadata format # but got stuck without ever being able to build consensus on # it and ultimately ended up withdrawn. # # However, a number of tools had started emitting METADATA with # `2.0` Metadata-Version, so for historical reasons, this version # was skipped. # Metadata 2.1 - PEP 566 description_content_type: str provides_extra: list[str] # Metadata 2.2 - PEP 643 dynamic: list[str] # Metadata 2.3 - PEP 685 # No new fields were added in PEP 685, just some edge case were # tightened up to provide better interoptability. # Metadata 2.4 - PEP 639 license_expression: str license_files: list[str] _STRING_FIELDS = { "author", "author_email", "description", "description_content_type", "download_url", "home_page", "license", "license_expression", "maintainer", "maintainer_email", "metadata_version", "name", "requires_python", "summary", "version", } _LIST_FIELDS = { "classifiers", "dynamic", "license_files", "obsoletes", "obsoletes_dist", "platforms", "provides", "provides_dist", "provides_extra", "requires", "requires_dist", "requires_external", "supported_platforms", } _DICT_FIELDS = { "project_urls", } def _parse_keywords(data: str) -> list[str]: """Split a string of comma-separated keywords into a list of keywords.""" return [k.strip() for k in data.split(",")] def _parse_project_urls(data: list[str]) -> dict[str, str]: """Parse a list of label/URL string pairings separated by a comma.""" urls = {} for pair in data: # Our logic is slightly tricky here as we want to try and do # *something* reasonable with malformed data. # # The main thing that we have to worry about, is data that does # not have a ',' at all to split the label from the Value. There # isn't a singular right answer here, and we will fail validation # later on (if the caller is validating) so it doesn't *really* # matter, but since the missing value has to be an empty str # and our return value is dict[str, str], if we let the key # be the missing value, then they'd have multiple '' values that # overwrite each other in a accumulating dict. # # The other potentional issue is that it's possible to have the # same label multiple times in the metadata, with no solid "right" # answer with what to do in that case. As such, we'll do the only # thing we can, which is treat the field as unparseable and add it # to our list of unparsed fields. parts = [p.strip() for p in pair.split(",", 1)] parts.extend([""] * (max(0, 2 - len(parts)))) # Ensure 2 items # TODO: The spec doesn't say anything about if the keys should be # considered case sensitive or not... logically they should # be case-preserving and case-insensitive, but doing that # would open up more cases where we might have duplicate # entries. label, url = parts if label in urls: # The label already exists in our set of urls, so this field # is unparseable, and we can just add the whole thing to our # unparseable data and stop processing it. raise KeyError("duplicate labels in project urls") urls[label] = url return urls def _get_payload(msg: email.message.Message, source: bytes | str) -> str: """Get the body of the message.""" # If our source is a str, then our caller has managed encodings for us, # and we don't need to deal with it. if isinstance(source, str): payload = msg.get_payload() assert isinstance(payload, str) return payload # If our source is a bytes, then we're managing the encoding and we need # to deal with it. else: bpayload = msg.get_payload(decode=True) assert isinstance(bpayload, bytes) try: return bpayload.decode("utf8", "strict") except UnicodeDecodeError as exc: raise ValueError("payload in an invalid encoding") from exc # The various parse_FORMAT functions here are intended to be as lenient as # possible in their parsing, while still returning a correctly typed # RawMetadata. # # To aid in this, we also generally want to do as little touching of the # data as possible, except where there are possibly some historic holdovers # that make valid data awkward to work with. # # While this is a lower level, intermediate format than our ``Metadata`` # class, some light touch ups can make a massive difference in usability. # Map METADATA fields to RawMetadata. _EMAIL_TO_RAW_MAPPING = { "author": "author", "author-email": "author_email", "classifier": "classifiers", "description": "description", "description-content-type": "description_content_type", "download-url": "download_url", "dynamic": "dynamic", "home-page": "home_page", "keywords": "keywords", "license": "license", "license-expression": "license_expression", "license-file": "license_files", "maintainer": "maintainer", "maintainer-email": "maintainer_email", "metadata-version": "metadata_version", "name": "name", "obsoletes": "obsoletes", "obsoletes-dist": "obsoletes_dist", "platform": "platforms", "project-url": "project_urls", "provides": "provides", "provides-dist": "provides_dist", "provides-extra": "provides_extra", "requires": "requires", "requires-dist": "requires_dist", "requires-external": "requires_external", "requires-python": "requires_python", "summary": "summary", "supported-platform": "supported_platforms", "version": "version", } _RAW_TO_EMAIL_MAPPING = {raw: email for email, raw in _EMAIL_TO_RAW_MAPPING.items()} def parse_email(data: bytes | str) -> tuple[RawMetadata, dict[str, list[str]]]: """Parse a distribution's metadata stored as email headers (e.g. from ``METADATA``). This function returns a two-item tuple of dicts. The first dict is of recognized fields from the core metadata specification. Fields that can be parsed and translated into Python's built-in types are converted appropriately. All other fields are left as-is. Fields that are allowed to appear multiple times are stored as lists. The second dict contains all other fields from the metadata. This includes any unrecognized fields. It also includes any fields which are expected to be parsed into a built-in type but were not formatted appropriately. Finally, any fields that are expected to appear only once but are repeated are included in this dict. """ raw: dict[str, str | list[str] | dict[str, str]] = {} unparsed: dict[str, list[str]] = {} if isinstance(data, str): parsed = email.parser.Parser(policy=email.policy.compat32).parsestr(data) else: parsed = email.parser.BytesParser(policy=email.policy.compat32).parsebytes(data) # We have to wrap parsed.keys() in a set, because in the case of multiple # values for a key (a list), the key will appear multiple times in the # list of keys, but we're avoiding that by using get_all(). for name in frozenset(parsed.keys()): # Header names in RFC are case insensitive, so we'll normalize to all # lower case to make comparisons easier. name = name.lower() # We use get_all() here, even for fields that aren't multiple use, # because otherwise someone could have e.g. two Name fields, and we # would just silently ignore it rather than doing something about it. headers = parsed.get_all(name) or [] # The way the email module works when parsing bytes is that it # unconditionally decodes the bytes as ascii using the surrogateescape # handler. When you pull that data back out (such as with get_all() ), # it looks to see if the str has any surrogate escapes, and if it does # it wraps it in a Header object instead of returning the string. # # As such, we'll look for those Header objects, and fix up the encoding. value = [] # Flag if we have run into any issues processing the headers, thus # signalling that the data belongs in 'unparsed'. valid_encoding = True for h in headers: # It's unclear if this can return more types than just a Header or # a str, so we'll just assert here to make sure. assert isinstance(h, (email.header.Header, str)) # If it's a header object, we need to do our little dance to get # the real data out of it. In cases where there is invalid data # we're going to end up with mojibake, but there's no obvious, good # way around that without reimplementing parts of the Header object # ourselves. # # That should be fine since, if mojibacked happens, this key is # going into the unparsed dict anyways. if isinstance(h, email.header.Header): # The Header object stores it's data as chunks, and each chunk # can be independently encoded, so we'll need to check each # of them. chunks: list[tuple[bytes, str | None]] = [] for bin, encoding in email.header.decode_header(h): try: bin.decode("utf8", "strict") except UnicodeDecodeError: # Enable mojibake. encoding = "latin1" valid_encoding = False else: encoding = "utf8" chunks.append((bin, encoding)) # Turn our chunks back into a Header object, then let that # Header object do the right thing to turn them into a # string for us. value.append(str(email.header.make_header(chunks))) # This is already a string, so just add it. else: value.append(h) # We've processed all of our values to get them into a list of str, # but we may have mojibake data, in which case this is an unparsed # field. if not valid_encoding: unparsed[name] = value continue raw_name = _EMAIL_TO_RAW_MAPPING.get(name) if raw_name is None: # This is a bit of a weird situation, we've encountered a key that # we don't know what it means, so we don't know whether it's meant # to be a list or not. # # Since we can't really tell one way or another, we'll just leave it # as a list, even though it may be a single item list, because that's # what makes the most sense for email headers. unparsed[name] = value continue # If this is one of our string fields, then we'll check to see if our # value is a list of a single item. If it is then we'll assume that # it was emitted as a single string, and unwrap the str from inside # the list. # # If it's any other kind of data, then we haven't the faintest clue # what we should parse it as, and we have to just add it to our list # of unparsed stuff. if raw_name in _STRING_FIELDS and len(value) == 1: raw[raw_name] = value[0] # If this is one of our list of string fields, then we can just assign # the value, since email *only* has strings, and our get_all() call # above ensures that this is a list. elif raw_name in _LIST_FIELDS: raw[raw_name] = value # Special Case: Keywords # The keywords field is implemented in the metadata spec as a str, # but it conceptually is a list of strings, and is serialized using # ", ".join(keywords), so we'll do some light data massaging to turn # this into what it logically is. elif raw_name == "keywords" and len(value) == 1: raw[raw_name] = _parse_keywords(value[0]) # Special Case: Project-URL # The project urls is implemented in the metadata spec as a list of # specially-formatted strings that represent a key and a value, which # is fundamentally a mapping, however the email format doesn't support # mappings in a sane way, so it was crammed into a list of strings # instead. # # We will do a little light data massaging to turn this into a map as # it logically should be. elif raw_name == "project_urls": try: raw[raw_name] = _parse_project_urls(value) except KeyError: unparsed[name] = value # Nothing that we've done has managed to parse this, so it'll just # throw it in our unparseable data and move on. else: unparsed[name] = value # We need to support getting the Description from the message payload in # addition to getting it from the the headers. This does mean, though, there # is the possibility of it being set both ways, in which case we put both # in 'unparsed' since we don't know which is right. try: payload = _get_payload(parsed, data) except ValueError: unparsed.setdefault("description", []).append( parsed.get_payload(decode=isinstance(data, bytes)) # type: ignore[call-overload] ) else: if payload: # Check to see if we've already got a description, if so then both # it, and this body move to unparseable. if "description" in raw: description_header = cast(str, raw.pop("description")) unparsed.setdefault("description", []).extend( [description_header, payload] ) elif "description" in unparsed: unparsed["description"].append(payload) else: raw["description"] = payload # We need to cast our `raw` to a metadata, because a TypedDict only support # literal key names, but we're computing our key names on purpose, but the # way this function is implemented, our `TypedDict` can only have valid key # names. return cast(RawMetadata, raw), unparsed _NOT_FOUND = object() # Keep the two values in sync. _VALID_METADATA_VERSIONS = ["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4"] _MetadataVersion = Literal["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4"] _REQUIRED_ATTRS = frozenset(["metadata_version", "name", "version"]) class _Validator(Generic[T]): """Validate a metadata field. All _process_*() methods correspond to a core metadata field. The method is called with the field's raw value. If the raw value is valid it is returned in its "enriched" form (e.g. ``version.Version`` for the ``Version`` field). If the raw value is invalid, :exc:`InvalidMetadata` is raised (with a cause as appropriate). """ name: str raw_name: str added: _MetadataVersion def __init__( self, *, added: _MetadataVersion = "1.0", ) -> None: self.added = added def __set_name__(self, _owner: Metadata, name: str) -> None: self.name = name self.raw_name = _RAW_TO_EMAIL_MAPPING[name] def __get__(self, instance: Metadata, _owner: type[Metadata]) -> T: # With Python 3.8, the caching can be replaced with functools.cached_property(). # No need to check the cache as attribute lookup will resolve into the # instance's __dict__ before __get__ is called. cache = instance.__dict__ value = instance._raw.get(self.name) # To make the _process_* methods easier, we'll check if the value is None # and if this field is NOT a required attribute, and if both of those # things are true, we'll skip the the converter. This will mean that the # converters never have to deal with the None union. if self.name in _REQUIRED_ATTRS or value is not None: try: converter: Callable[[Any], T] = getattr(self, f"_process_{self.name}") except AttributeError: pass else: value = converter(value) cache[self.name] = value try: del instance._raw[self.name] # type: ignore[misc] except KeyError: pass return cast(T, value) def _invalid_metadata( self, msg: str, cause: Exception | None = None ) -> InvalidMetadata: exc = InvalidMetadata( self.raw_name, msg.format_map({"field": repr(self.raw_name)}) ) exc.__cause__ = cause return exc def _process_metadata_version(self, value: str) -> _MetadataVersion: # Implicitly makes Metadata-Version required. if value not in _VALID_METADATA_VERSIONS: raise self._invalid_metadata(f"{value!r} is not a valid metadata version") return cast(_MetadataVersion, value) def _process_name(self, value: str) -> str: if not value: raise self._invalid_metadata("{field} is a required field") # Validate the name as a side-effect. try: utils.canonicalize_name(value, validate=True) except utils.InvalidName as exc: raise self._invalid_metadata( f"{value!r} is invalid for {{field}}", cause=exc ) from exc else: return value def _process_version(self, value: str) -> version_module.Version: if not value: raise self._invalid_metadata("{field} is a required field") try: return version_module.parse(value) except version_module.InvalidVersion as exc: raise self._invalid_metadata( f"{value!r} is invalid for {{field}}", cause=exc ) from exc def _process_summary(self, value: str) -> str: """Check the field contains no newlines.""" if "\n" in value: raise self._invalid_metadata("{field} must be a single line") return value def _process_description_content_type(self, value: str) -> str: content_types = {"text/plain", "text/x-rst", "text/markdown"} message = email.message.EmailMessage() message["content-type"] = value content_type, parameters = ( # Defaults to `text/plain` if parsing failed. message.get_content_type().lower(), message["content-type"].params, ) # Check if content-type is valid or defaulted to `text/plain` and thus was # not parseable. if content_type not in content_types or content_type not in value.lower(): raise self._invalid_metadata( f"{{field}} must be one of {list(content_types)}, not {value!r}" ) charset = parameters.get("charset", "UTF-8") if charset != "UTF-8": raise self._invalid_metadata( f"{{field}} can only specify the UTF-8 charset, not {list(charset)}" ) markdown_variants = {"GFM", "CommonMark"} variant = parameters.get("variant", "GFM") # Use an acceptable default. if content_type == "text/markdown" and variant not in markdown_variants: raise self._invalid_metadata( f"valid Markdown variants for {{field}} are {list(markdown_variants)}, " f"not {variant!r}", ) return value def _process_dynamic(self, value: list[str]) -> list[str]: for dynamic_field in map(str.lower, value): if dynamic_field in {"name", "version", "metadata-version"}: raise self._invalid_metadata( f"{dynamic_field!r} is not allowed as a dynamic field" ) elif dynamic_field not in _EMAIL_TO_RAW_MAPPING: raise self._invalid_metadata( f"{dynamic_field!r} is not a valid dynamic field" ) return list(map(str.lower, value)) def _process_provides_extra( self, value: list[str], ) -> list[utils.NormalizedName]: normalized_names = [] try: for name in value: normalized_names.append(utils.canonicalize_name(name, validate=True)) except utils.InvalidName as exc: raise self._invalid_metadata( f"{name!r} is invalid for {{field}}", cause=exc ) from exc else: return normalized_names def _process_requires_python(self, value: str) -> specifiers.SpecifierSet: try: return specifiers.SpecifierSet(value) except specifiers.InvalidSpecifier as exc: raise self._invalid_metadata( f"{value!r} is invalid for {{field}}", cause=exc ) from exc def _process_requires_dist( self, value: list[str], ) -> list[requirements.Requirement]: reqs = [] try: for req in value: reqs.append(requirements.Requirement(req)) except requirements.InvalidRequirement as exc: raise self._invalid_metadata( f"{req!r} is invalid for {{field}}", cause=exc ) from exc else: return reqs def _process_license_expression( self, value: str ) -> NormalizedLicenseExpression | None: try: return licenses.canonicalize_license_expression(value) except ValueError as exc: raise self._invalid_metadata( f"{value!r} is invalid for {{field}}", cause=exc ) from exc def _process_license_files(self, value: list[str]) -> list[str]: paths = [] for path in value: if ".." in path: raise self._invalid_metadata( f"{path!r} is invalid for {{field}}, " "parent directory indicators are not allowed" ) if "*" in path: raise self._invalid_metadata( f"{path!r} is invalid for {{field}}, paths must be resolved" ) if ( pathlib.PurePosixPath(path).is_absolute() or pathlib.PureWindowsPath(path).is_absolute() ): raise self._invalid_metadata( f"{path!r} is invalid for {{field}}, paths must be relative" ) if pathlib.PureWindowsPath(path).as_posix() != path: raise self._invalid_metadata( f"{path!r} is invalid for {{field}}, paths must use '/' delimiter" ) paths.append(path) return paths class Metadata: """Representation of distribution metadata. Compared to :class:`RawMetadata`, this class provides objects representing metadata fields instead of only using built-in types. Any invalid metadata will cause :exc:`InvalidMetadata` to be raised (with a :py:attr:`~BaseException.__cause__` attribute as appropriate). """ _raw: RawMetadata @classmethod def from_raw(cls, data: RawMetadata, *, validate: bool = True) -> Metadata: """Create an instance from :class:`RawMetadata`. If *validate* is true, all metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. """ ins = cls() ins._raw = data.copy() # Mutations occur due to caching enriched values. if validate: exceptions: list[Exception] = [] try: metadata_version = ins.metadata_version metadata_age = _VALID_METADATA_VERSIONS.index(metadata_version) except InvalidMetadata as metadata_version_exc: exceptions.append(metadata_version_exc) metadata_version = None # Make sure to check for the fields that are present, the required # fields (so their absence can be reported). fields_to_check = frozenset(ins._raw) | _REQUIRED_ATTRS # Remove fields that have already been checked. fields_to_check -= {"metadata_version"} for key in fields_to_check: try: if metadata_version: # Can't use getattr() as that triggers descriptor protocol which # will fail due to no value for the instance argument. try: field_metadata_version = cls.__dict__[key].added except KeyError: exc = InvalidMetadata(key, f"unrecognized field: {key!r}") exceptions.append(exc) continue field_age = _VALID_METADATA_VERSIONS.index( field_metadata_version ) if field_age > metadata_age: field = _RAW_TO_EMAIL_MAPPING[key] exc = InvalidMetadata( field, f"{field} introduced in metadata version " f"{field_metadata_version}, not {metadata_version}", ) exceptions.append(exc) continue getattr(ins, key) except InvalidMetadata as exc: exceptions.append(exc) if exceptions: raise ExceptionGroup("invalid metadata", exceptions) return ins @classmethod def from_email(cls, data: bytes | str, *, validate: bool = True) -> Metadata: """Parse metadata from email headers. If *validate* is true, the metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. """ raw, unparsed = parse_email(data) if validate: exceptions: list[Exception] = [] for unparsed_key in unparsed: if unparsed_key in _EMAIL_TO_RAW_MAPPING: message = f"{unparsed_key!r} has invalid data" else: message = f"unrecognized field: {unparsed_key!r}" exceptions.append(InvalidMetadata(unparsed_key, message)) if exceptions: raise ExceptionGroup("unparsed", exceptions) try: return cls.from_raw(raw, validate=validate) except ExceptionGroup as exc_group: raise ExceptionGroup( "invalid or unparsed metadata", exc_group.exceptions ) from None metadata_version: _Validator[_MetadataVersion] = _Validator() """:external:ref:`core-metadata-metadata-version` (required; validated to be a valid metadata version)""" # `name` is not normalized/typed to NormalizedName so as to provide access to # the original/raw name. name: _Validator[str] = _Validator() """:external:ref:`core-metadata-name` (required; validated using :func:`~packaging.utils.canonicalize_name` and its *validate* parameter)""" version: _Validator[version_module.Version] = _Validator() """:external:ref:`core-metadata-version` (required)""" dynamic: _Validator[list[str] | None] = _Validator( added="2.2", ) """:external:ref:`core-metadata-dynamic` (validated against core metadata field names and lowercased)""" platforms: _Validator[list[str] | None] = _Validator() """:external:ref:`core-metadata-platform`""" supported_platforms: _Validator[list[str] | None] = _Validator(added="1.1") """:external:ref:`core-metadata-supported-platform`""" summary: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-summary` (validated to contain no newlines)""" description: _Validator[str | None] = _Validator() # TODO 2.1: can be in body """:external:ref:`core-metadata-description`""" description_content_type: _Validator[str | None] = _Validator(added="2.1") """:external:ref:`core-metadata-description-content-type` (validated)""" keywords: _Validator[list[str] | None] = _Validator() """:external:ref:`core-metadata-keywords`""" home_page: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-home-page`""" download_url: _Validator[str | None] = _Validator(added="1.1") """:external:ref:`core-metadata-download-url`""" author: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-author`""" author_email: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-author-email`""" maintainer: _Validator[str | None] = _Validator(added="1.2") """:external:ref:`core-metadata-maintainer`""" maintainer_email: _Validator[str | None] = _Validator(added="1.2") """:external:ref:`core-metadata-maintainer-email`""" license: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-license`""" license_expression: _Validator[NormalizedLicenseExpression | None] = _Validator( added="2.4" ) """:external:ref:`core-metadata-license-expression`""" license_files: _Validator[list[str] | None] = _Validator(added="2.4") """:external:ref:`core-metadata-license-file`""" classifiers: _Validator[list[str] | None] = _Validator(added="1.1") """:external:ref:`core-metadata-classifier`""" requires_dist: _Validator[list[requirements.Requirement] | None] = _Validator( added="1.2" ) """:external:ref:`core-metadata-requires-dist`""" requires_python: _Validator[specifiers.SpecifierSet | None] = _Validator( added="1.2" ) """:external:ref:`core-metadata-requires-python`""" # Because `Requires-External` allows for non-PEP 440 version specifiers, we # don't do any processing on the values. requires_external: _Validator[list[str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-requires-external`""" project_urls: _Validator[dict[str, str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-project-url`""" # PEP 685 lets us raise an error if an extra doesn't pass `Name` validation # regardless of metadata version. provides_extra: _Validator[list[utils.NormalizedName] | None] = _Validator( added="2.1", ) """:external:ref:`core-metadata-provides-extra`""" provides_dist: _Validator[list[str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-provides-dist`""" obsoletes_dist: _Validator[list[str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-obsoletes-dist`""" requires: _Validator[list[str] | None] = _Validator(added="1.1") """``Requires`` (deprecated)""" provides: _Validator[list[str] | None] = _Validator(added="1.1") """``Provides`` (deprecated)""" obsoletes: _Validator[list[str] | None] = _Validator(added="1.1") """``Obsoletes`` (deprecated)""" _tokenizer.py 0000644 00000012254 15030064363 0007273 0 ustar 00 import contextlib import re from dataclasses import dataclass from typing import Dict, Iterator, NoReturn, Optional, Tuple, Union from .specifiers import Specifier @dataclass class Token: name: str text: str position: int class ParserSyntaxError(Exception): """The provided source text could not be parsed correctly.""" def __init__( self, message: str, *, source: str, span: Tuple[int, int], ) -> None: self.span = span self.message = message self.source = source super().__init__() def __str__(self) -> str: marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^" return "\n ".join([self.message, self.source, marker]) DEFAULT_RULES: "Dict[str, Union[str, re.Pattern[str]]]" = { "LEFT_PARENTHESIS": r"\(", "RIGHT_PARENTHESIS": r"\)", "LEFT_BRACKET": r"\[", "RIGHT_BRACKET": r"\]", "SEMICOLON": r";", "COMMA": r",", "QUOTED_STRING": re.compile( r""" ( ('[^']*') | ("[^"]*") ) """, re.VERBOSE, ), "OP": r"(===|==|~=|!=|<=|>=|<|>)", "BOOLOP": r"\b(or|and)\b", "IN": r"\bin\b", "NOT": r"\bnot\b", "VARIABLE": re.compile( r""" \b( python_version |python_full_version |os[._]name |sys[._]platform |platform_(release|system) |platform[._](version|machine|python_implementation) |python_implementation |implementation_(name|version) |extra )\b """, re.VERBOSE, ), "SPECIFIER": re.compile( Specifier._operator_regex_str + Specifier._version_regex_str, re.VERBOSE | re.IGNORECASE, ), "AT": r"\@", "URL": r"[^ \t]+", "IDENTIFIER": r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b", "VERSION_PREFIX_TRAIL": r"\.\*", "VERSION_LOCAL_LABEL_TRAIL": r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*", "WS": r"[ \t]+", "END": r"$", } class Tokenizer: """Context-sensitive token parsing. Provides methods to examine the input stream to check whether the next token matches. """ def __init__( self, source: str, *, rules: "Dict[str, Union[str, re.Pattern[str]]]", ) -> None: self.source = source self.rules: Dict[str, re.Pattern[str]] = { name: re.compile(pattern) for name, pattern in rules.items() } self.next_token: Optional[Token] = None self.position = 0 def consume(self, name: str) -> None: """Move beyond provided token name, if at current position.""" if self.check(name): self.read() def check(self, name: str, *, peek: bool = False) -> bool: """Check whether the next token has the provided name. By default, if the check succeeds, the token *must* be read before another check. If `peek` is set to `True`, the token is not loaded and would need to be checked again. """ assert ( self.next_token is None ), f"Cannot check for {name!r}, already have {self.next_token!r}" assert name in self.rules, f"Unknown token name: {name!r}" expression = self.rules[name] match = expression.match(self.source, self.position) if match is None: return False if not peek: self.next_token = Token(name, match[0], self.position) return True def expect(self, name: str, *, expected: str) -> Token: """Expect a certain token name next, failing with a syntax error otherwise. The token is *not* read. """ if not self.check(name): raise self.raise_syntax_error(f"Expected {expected}") return self.read() def read(self) -> Token: """Consume the next token and return it.""" token = self.next_token assert token is not None self.position += len(token.text) self.next_token = None return token def raise_syntax_error( self, message: str, *, span_start: Optional[int] = None, span_end: Optional[int] = None, ) -> NoReturn: """Raise ParserSyntaxError at the given position.""" span = ( self.position if span_start is None else span_start, self.position if span_end is None else span_end, ) raise ParserSyntaxError( message, source=self.source, span=span, ) @contextlib.contextmanager def enclosing_tokens( self, open_token: str, close_token: str, *, around: str ) -> Iterator[None]: if self.check(open_token): open_position = self.position self.read() else: open_position = None yield if open_position is None: return if not self.check(close_token): self.raise_syntax_error( f"Expected matching {close_token} for {open_token}, after {around}", span_start=open_position, ) self.read() _elffile.py 0000644 00000006302 15030064363 0006664 0 ustar 00 """ ELF file parser. This provides a class ``ELFFile`` that parses an ELF executable in a similar interface to ``ZipFile``. Only the read interface is implemented. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html """ import enum import os import struct from typing import IO, Optional, Tuple class ELFInvalid(ValueError): pass class EIClass(enum.IntEnum): C32 = 1 C64 = 2 class EIData(enum.IntEnum): Lsb = 1 Msb = 2 class EMachine(enum.IntEnum): I386 = 3 S390 = 22 Arm = 40 X8664 = 62 AArc64 = 183 class ELFFile: """ Representation of an ELF executable. """ def __init__(self, f: IO[bytes]) -> None: self._f = f try: ident = self._read("16B") except struct.error: raise ELFInvalid("unable to parse identification") magic = bytes(ident[:4]) if magic != b"\x7fELF": raise ELFInvalid(f"invalid magic: {magic!r}") self.capacity = ident[4] # Format for program header (bitness). self.encoding = ident[5] # Data structure encoding (endianness). try: # e_fmt: Format for program header. # p_fmt: Format for section header. # p_idx: Indexes to find p_type, p_offset, and p_filesz. e_fmt, self._p_fmt, self._p_idx = { (1, 1): ("<HHIIIIIHHH", "<IIIIIIII", (0, 1, 4)), # 32-bit LSB. (1, 2): (">HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)), # 32-bit MSB. (2, 1): ("<HHIQQQIHHH", "<IIQQQQQQ", (0, 2, 5)), # 64-bit LSB. (2, 2): (">HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)), # 64-bit MSB. }[(self.capacity, self.encoding)] except KeyError: raise ELFInvalid( f"unrecognized capacity ({self.capacity}) or " f"encoding ({self.encoding})" ) try: ( _, self.machine, # Architecture type. _, _, self._e_phoff, # Offset of program header. _, self.flags, # Processor-specific flags. _, self._e_phentsize, # Size of section. self._e_phnum, # Number of sections. ) = self._read(e_fmt) except struct.error as e: raise ELFInvalid("unable to parse machine and section information") from e def _read(self, fmt: str) -> Tuple[int, ...]: return struct.unpack(fmt, self._f.read(struct.calcsize(fmt))) @property def interpreter(self) -> Optional[str]: """ The path recorded in the ``PT_INTERP`` section header. """ for index in range(self._e_phnum): self._f.seek(self._e_phoff + self._e_phentsize * index) try: data = self._read(self._p_fmt) except struct.error: continue if data[self._p_idx[0]] != 3: # Not PT_INTERP. continue self._f.seek(data[self._p_idx[1]]) return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0") return None __pycache__/metadata.cpython-310.pyc 0000644 00000044440 15030075717 0013250 0 ustar 00 o �h�� � @ s d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl Z d dl m Z m Z m Z mZmZmZ ddlmZmZmZmZ ddlmZ ddlmZ e �d�Ze jd kr[e Z nG d d � d e �Z G d d � d e �Z G dd� dedd�Z h d�Z!h d�Z"dhZ#dVdd�Z$dWd d �Z%dXd"d#�Z&i d$d$�d%d&�d'd(�d)d)�d*d+�d,d-�d.d.�d/d0�d1d1�d2d2�d3d4�d5d6�d7d7�d8d9�d:d;�d<d<�d=d=�d>d?dd@dAdBdCdDdEdFdGdHdIdJ� �Z'dKdL� e'�(� D �Z)dYdNdO�Z*e+� Z,g dP�Z-edP Z.e/g dQ��Z0G dRdS� dSe e �Z1G dTdU� dU�Z2dS )Z� )� annotationsN)�Any�Callable�Generic�Literal� TypedDict�cast� )�licenses� requirements� specifiers�utils)�version)�NormalizedLicenseExpression�T)� � c @ s6 e Zd ZU dZded< ded< d dd �Zdd d �Zd S )�ExceptionGroupz�A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11. If :external:exc:`ExceptionGroup` is already defined by Python itself, that version is used instead. �str�message�list[Exception]� exceptions�return�Nonec C s || _ || _d S �N)r r )�selfr r � r �H/usr/local/CyberPanel/lib/python3.10/site-packages/packaging/metadata.py�__init__) s zExceptionGroup.__init__c C s | j j� d| j�d| j�d�S )N�(z, �))� __class__�__name__r r )r r r r �__repr__- s zExceptionGroup.__repr__N)r r r r r r )r r )r" � __module__� __qualname__�__doc__�__annotations__r r# r r r r r s r c s. e Zd ZU dZded< d � fdd� Z� ZS ) �InvalidMetadataz'A metadata field contains invalid data.r �fieldr r r c s || _ t� �|� d S r )r) �superr )r r) r �r! r r r 7 s zInvalidMetadata.__init__)r) r r r r r )r" r$ r% r& r' r � __classcell__r r r+ r r( 1 s r( c @ s e Zd ZU dZded< ded< ded< ded< ded< ded < ded < ded < ded < ded < ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< d ed < ded < ded < ded < ded!< ded"< d#S )$� RawMetadataa� A dictionary of raw core metadata. Each field in core metadata maps to a key of this dictionary (when data is provided). The key is lower-case and underscores are used instead of dashes compared to the equivalent core metadata field. Any core metadata field that can be specified multiple times or can hold multiple values in a single field have a key with a plural name. See :class:`Metadata` whose attributes match the keys of this dictionary. Core metadata fields that can be specified multiple times are stored as a list or dict depending on which is appropriate for the field. Any fields which hold multiple values in a single field are stored as a list. r �metadata_version�namer � list[str]� platforms�summary� description�keywords� home_page�author� author_email�license�supported_platforms� download_url� classifiers�requires�provides� obsoletes� maintainer�maintainer_email� requires_dist� provides_dist�obsoletes_dist�requires_python�requires_external�dict[str, str]� project_urls�description_content_type�provides_extra�dynamic�license_expression� license_filesN)r" r$ r% r& r' r r r r r- @ s@ r- F)�total> r/ r6 r8 r2 r r5 r? r3 r7 r: rD r@ r. rK rH > rJ r= r< r> r1 r; rL rB rA rC rI rE r9 rG �datar r r0 c C s dd� | � d�D �S )zCSplit a string of comma-separated keywords into a list of keywords.c S � g | ]}|� � �qS r ��strip)�.0�kr r r � <listcomp>� � z#_parse_keywords.<locals>.<listcomp>�,)�split)rN r r r �_parse_keywords� s rX rF c C sf i }| D ],}dd� |� dd�D �}|�dgtddt|� � � |\}}||v r,td��|||< q|S ) z?Parse a list of label/URL string pairings separated by a comma.c S rO r rP )rR �pr r r rT � rU z'_parse_project_urls.<locals>.<listcomp>rV r � r � z duplicate labels in project urls)rW �extend�max�len�KeyError)rN �urls�pair�parts�label�urlr r r �_parse_project_urls� s re �msg�email.message.Message�source� bytes | strc C sp t |t�r| �� }t |t�sJ �|S | jdd�}t |t�s J �z|�dd�W S ty7 } ztd�|�d}~ww )z Get the body of the message.T��decode�utf8�strictz payload in an invalid encodingN)� isinstancer � get_payload�bytesrk �UnicodeDecodeError� ValueError)rf rh �payload�bpayload�excr r r � _get_payload� s ��rv r6 z author-emailr7 � classifierr; r3 zdescription-content-typerH z download-urlr: rJ z home-pager5 r4 r8 zlicense-expressionrK z license-filerL r? zmaintainer-emailr@ �metadata-versionr. r/ r> rC r1 r= rB rI r< rA rE rD r2 r9 r ) zobsoletes-dist�platformz project-urlr= z provides-distzprovides-extrar< z requires-distzrequires-externalzrequires-pythonr2 zsupported-platformr c C s i | ]\}}||�qS r r )rR �email�rawr r r � <dictcomp> s r| �(tuple[RawMetadata, dict[str, list[str]]]c C s� i }i }t | t�rtjjtjjd��| �}n tjjtjjd�� | �}t |� � �D ]�}|� � }|� |�p4g }g }d}|D ]Q}t |tjjtf�sHJ �t |tjj�r�g } tj�|�D ]#\} } z| �dd� W n typ d} d}Y nw d} | �| | f� qW|�ttj�| ��� q;|�|� q;|s�|||< q(t�|�} | du r�|||< q(| tv r�t|�dkr�|d || < q(| tv r�||| < q(| d kr�t|�dkr�t|d �|| < q(| d kr�zt|�|| < W q( t y� |||< Y q(w |||< q(zt || �} W n t �y |� d g ��|j t | t!�d �� Y n.w | �r=d |v �r,t"t|�#d ��}|� d g ��$|| g� nd |v �r9|d �| � n| |d < t"t%|�|fS )a Parse a distribution's metadata stored as email headers (e.g. from ``METADATA``). This function returns a two-item tuple of dicts. The first dict is of recognized fields from the core metadata specification. Fields that can be parsed and translated into Python's built-in types are converted appropriately. All other fields are left as-is. Fields that are allowed to appear multiple times are stored as lists. The second dict contains all other fields from the metadata. This includes any unrecognized fields. It also includes any fields which are expected to be parsed into a built-in type but were not formatted appropriately. Finally, any fields that are expected to appear only once but are repeated are included in this dict. )�policyTrl rm �latin1FNr r r4 rG r3 rj )&rn r rz �parser�Parserr~ �compat32�parsestr� BytesParser� parsebytes� frozenset�keys�lower�get_all�header�Header� decode_headerrk rq �append� make_header�_EMAIL_TO_RAW_MAPPING�get�_STRING_FIELDSr^ � _LIST_FIELDSrX re r_ rv rr � setdefaultro rp r �popr\ r- )rN r{ �unparsed�parsedr/ �headers�value�valid_encoding�h�chunks�bin�encoding�raw_namers �description_headerr r r � parse_email s| � � �� � r� )�1.0�1.1�1.2�2.1�2.2z2.3�2.4)r. r/ r c @ s� e Zd ZU dZded< ded< ded< dd�d:d d �Zd;dd�Zd<dd�Z d=d>dd �Zd?d d �Z d@d d!�Z dAd#d$�Z d@d%d&�Z d@d'd(�Z dBd*d+�ZdCd-d.�ZdDd0d1�ZdEd3d4�ZdFd6d7�ZdBd8d9�ZdS )G� _Validatorav Validate a metadata field. All _process_*() methods correspond to a core metadata field. The method is called with the field's raw value. If the raw value is valid it is returned in its "enriched" form (e.g. ``version.Version`` for the ``Version`` field). If the raw value is invalid, :exc:`InvalidMetadata` is raised (with a cause as appropriate). r r/ r� �_MetadataVersion�addedr� �r� r r c C s || _ d S r r� )r r� r r r r � s z_Validator.__init__�_owner�Metadatac C s || _ t| | _d S r )r/ �_RAW_TO_EMAIL_MAPPINGr� )r r� r/ r r r � __set_name__� s z_Validator.__set_name__�instance�type[Metadata]r c C s� |j }|j�| j�}| jtv s|d ur,z t| d| j� ��}W n ty' Y nw ||�}||| j< z|j| j= W n tyA Y nw tt |�S )N� _process_) �__dict__�_rawr� r/ �_REQUIRED_ATTRS�getattr�AttributeErrorr_ r r )r r� r� �cacher� � converterr r r �__get__� s � � z_Validator.__get__Nrf �cause�Exception | Noner( c C s& t | j|�dt| j�i��}||_|S )Nr) )r( r� � format_map�repr� __cause__)r rf r� ru r r r �_invalid_metadata s �z _Validator._invalid_metadatar� c C s" |t vr | �|�d���tt|�S )Nz is not a valid metadata version)�_VALID_METADATA_VERSIONSr� r r� �r r� r r r �_process_metadata_version s z$_Validator._process_metadata_versionc C sT |s| � d��z tj|dd� W |S tjy) } z | j |�d�|d�|�d }~ww )N�{field} is a required fieldT��validate� is invalid for {field}�r� )r� r �canonicalize_name� InvalidName�r r� ru r r r � _process_name s � ����z_Validator._process_name�version_module.Versionc C sL |s| � d��zt�|�W S tjy% } z | j |�d�|d�|�d }~ww )Nr� r� r� )r� �version_module�parse�InvalidVersionr� r r r �_process_version( s ����z_Validator._process_versionc C s d|v r | � d��|S )z%Check the field contains no newlines.� z {field} must be a single line)r� r� r r r �_process_summary2 s z_Validator._process_summaryc C s� h d�}t j�� }||d< |�� �� |d j}}||vs#||�� vr0| �dt|�� d|����|�dd�}|dkrD| �dt|�� ���dd h}|�d d�}|d krc||vrc| �d t|�� d|����|S ) N> � text/plain� text/x-rst� text/markdownz content-typez{field} must be one of �, not �charsetzUTF-8z0{field} can only specify the UTF-8 charset, not �GFM� CommonMark�variantr� z(valid Markdown variants for {field} are ) rz r � EmailMessage�get_content_typer� �paramsr� �listr� ) r r� � content_typesr � content_type� parametersr� �markdown_variantsr� r r r �!_process_description_content_type8 s0 �� � ��z,_Validator._process_description_content_typer0 c C sR t tj|�D ]}|dv r| �|�d���|tvr | �|�d���qtt tj|��S )N> r/ r rx z" is not allowed as a dynamic fieldz is not a valid dynamic field)�mapr r� r� r� r� )r r� � dynamic_fieldr r r �_process_dynamicX s ���z_Validator._process_dynamic�list[utils.NormalizedName]c C sZ g }z|D ] }|� tj|dd�� qW |S tjy, } z | j|�d�|d�|�d }~ww )NTr� r� r� )r� r r� r� r� )r r� �normalized_namesr/ ru r r r �_process_provides_extrad s �� ����z"_Validator._process_provides_extra�specifiers.SpecifierSetc C s> zt �|�W S t jy } z | j|�d�|d�|�d }~ww �Nr� r� )r � SpecifierSet�InvalidSpecifierr� r� r r r �_process_requires_pythons s ����z#_Validator._process_requires_python� list[requirements.Requirement]c C sV g }z|D ] }|� t�|�� qW |S tjy* } z | j|�d�|d�|�d }~ww r� )r� r � Requirement�InvalidRequirementr� )r r� �reqs�reqru r r r �_process_requires_dist{ s �� ����z!_Validator._process_requires_dist�"NormalizedLicenseExpression | Nonec C s< zt �|�W S ty } z | j|�d�|d�|�d }~ww r� )r � canonicalize_license_expressionrr r� r� r r r �_process_license_expression� s ����z&_Validator._process_license_expressionc C s� g }|D ]F}d|v r| � |�d���d|v r | � |�d���t�|��� s,t�|��� r4| � |�d���t�|��� |krE| � |�d���|�|� q|S )Nz..zD is invalid for {field}, parent directory indicators are not allowed�*z/ is invalid for {field}, paths must be resolvedz/ is invalid for {field}, paths must be relativez5 is invalid for {field}, paths must use '/' delimiter)r� �pathlib� PurePosixPath� is_absolute�PureWindowsPath�as_posixr� )r r� �paths�pathr r r �_process_license_files� s. �� � ��� z!_Validator._process_license_files)r� r� r r )r� r� r/ r r r )r� r� r� r� r r r )rf r r� r� r r( )r� r r r� )r� r r r )r� r r r� )r� r0 r r0 )r� r0 r r� )r� r r r� )r� r0 r r� )r� r r r� )r" r$ r% r& r' r r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r� � s, � � r� c @ sl e Zd ZU dZded< edd�d>d d ��Zedd�d?d d��Ze� Z ded< e� Z ded< e� Z ded< edd�Z ded< e� Z ded< edd�Zded< e� Zd ed < e� Zd ed < ed d�Zd ed < e� Zded!< e� Zd ed"< edd�Zd ed#< e� Zd ed$< e� Zd ed%< ed&d�Zd ed'< ed&d�Zd ed(< e� Zd ed)< ed*d�Zd+ed,< ed*d�Zded-< edd�Z ded.< ed&d�Z d/ed0< ed&d�Z d1ed2< ed&d�Z ded3< ed&d�Z d4ed5< ed d�Z!d6ed7< ed&d�Z"ded8< ed&d�Z#ded9< edd�Z$ded:< edd�Z%ded;< edd�Z&ded<< d=S )@r� aJ Representation of distribution metadata. Compared to :class:`RawMetadata`, this class provides objects representing metadata fields instead of only using built-in types. Any invalid metadata will cause :exc:`InvalidMetadata` to be raised (with a :py:attr:`~BaseException.__cause__` attribute as appropriate). r- r� Tr� rN r� �boolr c C sV | � }|� � |_|r�g }z |j}t�|�}W n ty/ } z |�|� d}W Y d}~nd}~ww t|j�tB }|dh8 }|D ]c} zJ|r�z| j | j } W n t yb t| d| ���} |�| � Y W q>w t�| �} | |kr�t | } t| | � d| � d|� ��} |�| � W q>t || � W q> ty� } z |�| � W Y d} ~ q>d} ~ ww |r�td|��|S )z�Create an instance from :class:`RawMetadata`. If *validate* is true, all metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. Nr. �unrecognized field: z introduced in metadata version r� zinvalid metadata)�copyr� r. r� �indexr( r� r� r� r� r� r_ r� r� r )�clsrN r� �insr r. � metadata_age�metadata_version_exc�fields_to_check�key�field_metadata_versionru � field_ager) r r r �from_raw� s^ �� ����� �� zMetadata.from_rawri c C s� t |�\}}|r-g }|D ]}|tv r|�d�}nd|��}|�t||�� q |r-td|��z| j||d�W S tyH } ztd|j�d�d}~ww )z�Parse metadata from email headers. If *validate* is true, the metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. z has invalid datar r� r� z invalid or unparsed metadataN)r� r� r� r( r r r ) r rN r� r{ r� r � unparsed_keyr � exc_groupr r r � from_email� s( ����zMetadata.from_emailz _Validator[_MetadataVersion]r. z_Validator[str]r/ z"_Validator[version_module.Version]r r� r� z _Validator[list[str] | None]rJ r1 r� r9 z_Validator[str | None]r2 r3 r� rH r4 r5 r: r6 r7 r� r? r@ r8 r� z._Validator[NormalizedLicenseExpression | None]rK rL r; z1_Validator[list[requirements.Requirement] | None]rA z*_Validator[specifiers.SpecifierSet | None]rD rE z!_Validator[dict[str, str] | None]rG z-_Validator[list[utils.NormalizedName] | None]rI rB rC r< r= r> N)rN r- r� r r r� )rN ri r� r r r� )'r" r$ r% r& r' � classmethodr r r� r. r/ r rJ r1 r9 r2 r3 rH r4 r5 r: r6 r7 r? r@ r8 rK rL r; rA rD rE rG rI rB rC r< r= r> r r r r r� � s� 8�����r� )rN r r r0 )rN r0 r rF )rf rg rh ri r r )rN ri r r} )3� __future__r �email.feedparserrz � email.header� email.message� email.parser� email.policyr� �sys�typingr r r r r r rZ r r r r r r� r �TypeVarr � version_infor � Exceptionrr r( r- r� r� � _DICT_FIELDSrX re rv r� �itemsr� r� �object� _NOT_FOUNDr� r� r� r� r� r� r r r r �<module> s� H� ( �������� � � � � ������ 1 X licenses/__pycache__/__init__.cpython-310.pyc 0000644 00000005026 15030075717 0015031 0 ustar 00 o �hS � @ sn d dl mZ d dlZd dlmZmZ d dlmZmZ g d�Z e� d�Z ede �Z G dd � d e�Zdd d�ZdS )� )� annotationsN)�NewType�cast)� EXCEPTIONS�LICENSES)�InvalidLicenseExpression�NormalizedLicenseExpression� canonicalize_license_expressionz^[A-Za-z0-9.-]*$r c @ s e Zd ZdZdS )r z�Raised when a license-expression string is invalid >>> canonicalize_license_expression("invalid") Traceback (most recent call last): ... packaging.licenses.InvalidLicenseExpression: Invalid license expression: 'invalid' N)�__name__� __module__� __qualname__�__doc__� r r �Q/usr/local/CyberPanel/lib/python3.10/site-packages/packaging/licenses/__init__.pyr 2 s r �raw_license_expression�str�returnc s& | s d| ��}t |��| �dd��dd�}d� � fdd�|�� D �}|�� }|�� }g }|D ]0}|d vr:|�d � q.|d krD|�d � q.|dkrY|rY|d dvrYd| ��}t |��|�|� q.d�|�}z t|t� t� �}W n t yy d}Y nw |dur�d| ��}t |�d �g } |D ]t}|d v r�| �|� � � q�| r�| d dkr�|t vr�d|��}t |��| �t | d � q�|� d�r�|d d � } d} n|} d} | � d�r�t�| �s�d| ��}t |��| �|| | � q�| tvr�d| ��}t |��| �t| d | � q�d�| �} tt| �dd��dd��S ) Nz Invalid license expression: �(z ( �)z ) � LicenseRef-c s8 i | ]}|� � �� � � �r|� � d |t� �d� �qS )r N)�lower� startswith�len)�.0�ref��licenseref_prefixr r � <dictcomp>G s ��z3canonicalize_license_expression.<locals>.<dictcomp>> �or�and�withr r �Falser r ���> r r � TF�WITHzUnknown license exception: �id�+� z licenseref-zInvalid licenseref: zUnknown license: z( z ))r �replace�splitr �append�join�eval�globals�locals� Exception�upperr �endswithr �license_ref_allowed�matchr r r ) r �message�license_expression� license_refs�tokens� python_tokens�token�python_expression�invalid�normalized_tokens� final_token�suffix�normalized_expressionr r r r < st � � �r )r r r r )� __future__r �re�typingr r �packaging.licenses._spdxr r �__all__�compiler2 r r � ValueErrorr r r r r r �<module> s licenses/__pycache__/_spdx.cpython-310.pyc 0000644 00000117772 15030075717 0014423 0 ustar 00 o �h� � @ s - U d dl mZ d dlmZ G dd� de�ZG dd� de�ZdZi dd d d ��d d d d ��ddd d ��ddd d ��ddd d ��ddd d ��ddd d ��ddd d ��ddd d ��d d d d ��d d d d ��d d!d d ��d"d#d d ��d$d%d d ��d&d'd d ��d(d)d d ��d*d+d,d ��i d-d.d d ��d/d0d d ��d1d2d,d ��d3d4d d ��d5d6d d ��d7d8d d ��d9d:d d ��d;d<d d ��d=d>d d ��d?d@d d ��dAdBd d ��dCdDd d ��dEdFd d ��dGdHd d ��dIdJd d ��dKdLd d ��dMdNd d ���i dOdPd d ��dQdRd d ��dSdTd d ��dUdVd d ��dWdXd d ��dYdZd d ��d[d\d d ��d]d^d d ��d_d`d d ��dadbd d ��dcddd d ��dedfd d ��dgdhd d ��didjd d ��dkdld d ��dmdnd d ��dodpd d ���i dqdrd d ��dsdtd d ��dudvd d ��dwdxd d ��dydzd d ��d{d|d d ��d}d}d d ��d~dd d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d,d ���i d�d�d,d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ���i d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d,d ��d�d�d d ���i d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ���i d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ��d�d�d d ���d �dd d ���d�dd d ���d�dd d ���d�dd d ���d�d d d ���d �d d d ���d �d d d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���i �d�dd d ���d�dd d ���d �d d d ���d �d d d ���d �d!d d ���d"�d#d d ���d$�d%d d ���d&�d'd d ���d(�d)d d ���d*�d+d d ���d,�d-d d ���d.�d/d d ���d0�d1d d ���d2�d3d d ���d4�d5d d ���d6�d7d d ���d8�d9d d ���i �d:�d;d d ���d<�d=d d ���d>�d?d d ���d@�dAd d ���dB�dCd d ���dD�dEd d ���dF�dGd d ���dH�dId d ���dJ�dKd d ���dL�dMd d ���dN�dOd d ���dP�dQd d ���dR�dSd d ���dT�dUd d ���dV�dWd d ���dX�dYd d ���dZ�d[d d ���i �d\�d]d d ���d^�d_d d ���d`�dad d ���db�dcd d ���dd�ded d ���df�dgd d ���dh�did d ���dj�dkd d ���dl�dmd d ���dn�dod d ���dp�dpd d ���dq�dqd d ���dr�dsd d ���dt�dud d ���dv�dwd d ���dx�dyd d ���dz�d{d d ���i �d|�d}d d ���d~�dd d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���i �d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���i �d��d�d,d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���dÐd�d d ���dŐd�d d ���dǐd�d d ���dɐd�d d ���dːd�d d ���d͐d�d d ���dΐd�d d ���dАd�d d ���dҐd�d d ���dԐd�d d ���dd�d d ���dؐd�d d ���i �dڐd�d d ���dܐd�d d ���dސd�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d��d�d d ���d��d�d d ���d��d�d,d ���i �d��d�d d ���d��d�d d ���d��d d d ���d�dd d ���d�dd d ���d�dd d ���d�dd,d ���d �d d d ���d �d d d ���d �dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd,d ���d�dd d ���d�dd d ���d�d d d ���i �d �d d d ���d �d d d ���d!�d"d d ���d#�d$d d ���d%�d&d d ���d'�d(d d ���d)�d*d d ���d+�d,d d ���d-�d-d d ���d.�d/d,d ���d0�d1d,d ���d2�d3d d ���d4�d5d d ���d6�d7d,d ���d8�d9d,d ���d:�d;d d ���d<�d=d d ���i �d>�d?d,d ���d@�dAd,d ���dB�dCd,d ���dD�dEd,d ���dF�dGd,d ���dH�dId,d ���dJ�dKd,d ���dL�dMd d ���dN�dOd d ���dP�dQd,d ���dR�dSd,d ���dT�dUd d ���dV�dWd d ���dX�dXd d ���dY�dZd d ���d[�d\d d ���d]�d]d d ���i �d^�d_d d ���d`�dad d ���db�dcd d ���dd�ded d ���df�dgd d ���dh�did d ���dj�dkd d ���dl�dmd d ���dn�dod d ���dp�dqd d ���dr�dsd d ���dt�dud d ���dv�dwd d ���dx�dyd d ���dz�d{d d ���d|�d}d d ���d~�dd d ���i �d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���i �d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���dd�d d ���i �dĐd�d d ���dƐd�d d ���dȐd�d d ���dʐd�d d ���d̐d�d d ���dΐd�d d ���dАd�d d ���dҐd�d d ���dԐd�d,d ���dd�d,d ���dؐd�d d ���dڐd�d d ���dܐd�d,d ���dސd�d,d ���d�d�d d ���d�d�d d ���d�d�d,d ���i �d�d�d,d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d d d ���d�dd d ���d�dd d ���i �d�dd d ���d�dd d ���d �d d d ���d �d d d ���d �dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d �d d d ���d �d d d ���d �d!d d ���d"�d"d d ���d#�d#d d ���i �d$�d%d d ���d&�d'd d ���d(�d)d d ���d*�d*d d ���d+�d,d d ���d-�d.d d ���d/�d0d d ���d1�d2d d ���d3�d4d d ���d5�d6d d ���d7�d8d d ���d9�d:d d ���d;�d<d d ���d=�d>d d ���d?�d@d d ���dA�dBd d ���dC�dDd d ���i �dE�dFd d ���dG�dHd d ���dI�dJd d ���dK�dLd d ���dM�dNd d ���dO�dOd d ���dP�dPd d ���dQ�dRd d ���dS�dTd d ���dU�dVd d ���dW�dXd d ���dY�dYd d ���dZ�d[d d ���d\�d]d d ���d^�d_d d ���d`�dad d ���db�dcd d ���i �dd�ded d ���df�dgd d ���dh�did d ���dj�dkd d ���dl�dmd d ���dn�dod d ���dp�dqd d ���dr�dsd d ���dt�dud d ���dv�dwd d ���dx�dyd d ���dz�d{d,d ���d|�d}d d ���d~�dd d ���d��d�d d ���d��d�d d ���d��d�d d ���i �d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d,d ���d��d�d d ���d��d�d d ���i �d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���dd�d d ���dĐd�d d ���dƐd�d d ���dȐd�d d ���i �dʐd�d d ���d̐d�d d ���dΐd�d d ���dАd�d d ���dҐd�d d ���dԐd�d d ���dd�d d ���dؐd�d d ���dڐd�d d ���dܐd�d d ���dސd�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���i �d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d �dd d ���d�dd d ���d�dd d ���d�dd d ���d�d d d ���d �d d d ���d �d d d ���i �d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d �d d d ���d �d d d ���d �d!d d ���d"�d#d d ���d$�d%d d ���d&�d&d d ���d'�d'd d ���d(�d)d d ���d*�d+d d ���i �d,�d,d d ���d-�d.d d ���d/�d0d d ���d1�d2d d ���d3�d3d d ���d4�d5d d ���d6�d7d d ���d8�d9d d ���d:�d;d d ���d<�d=d d ���d>�d?d d ���d@�dAd d ���dB�dCd d ���dD�dEd d ���dF�dGd d ���dH�dId d ���dJ�dKd d ���i �dL�dMd d ���dN�dOd d ���dP�dQd d ���dR�dSd d ���dT�dUd d ���dV�dWd d ���dX�dYd d ���dZ�d[d d ���d\�d]d d ���d^�d_d d ���d`�dad d ���db�dcd d ���dd�ded d ���df�dgd d ���dh�did d ���dj�dkd d ���dl�dmd d ���i �dn�dod d ���dp�dqd d ���dr�drd d ���ds�dtd d ���du�dvd d ���dw�dxd d ���dy�dzd d ���d{�d|d d ���d}�d~d d ���d�dd d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d,d ���d��d�d d ���d��d�d d ���i �d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���i �d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���dÐd�d d ���dŐd�d d ���dǐd�d d ���dɐd�d d ���dːd�d d ���d͐d�d d ���i �dϐd�d d ���dѐd�d d ���dӐd�d d ���dՐd�d d ���dאd�d d ���dِd�d d ���dڐd�d d ���dܐd�d d ���dސd�d d ���d�d�d d ���d�d�d,d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���d�d�d d ���i �d�d�d d ���d�d�d d ���d�d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d �dd d ���d�dd d ���d�dd d ���d�dd d ���d�d d d ���d �d d d ���d �d d d ����d d d ��dd d ��dd d ��d��Z�de�d< i �d�dd d ���d�dd d ���d�dd d ���d�dd d ���d�dd d ���d �d d d ���d �d d d ���d �d!d d ���d"�d#d d ���d$�d%d d ���d&�d'd d ���d(�d)d d ���d*�d+d d ���d,�d-d d ���d.�d/d d ���d0�d1d d ���d2�d2d d ��i �d3�d4d d ���d5�d6d d ���d7�d7d d ���d8�d9d d ���d:�d:d d ���d;�d<d d ���d=�d>d d ���d?�d@d d ���dA�dBd d ���dC�dDd d ���dE�dFd d ���dG�dHd d ���dI�dId d ���dJ�dKd d ���dL�dMd d ���dN�dOd d ���dP�dQd d ���i �dR�dSd d ���dT�dUd d ���dV�dVd d ���dW�dXd d ���dY�dZd d ���d[�d\d d ���d]�d^d d ���d_�d`d d ���da�dbd d ���dc�ddd d ���de�dfd d ���dg�dgd d ���dh�did,d ���dj�dkd d ���dl�dmd d ���dn�dod d ���dp�dpd d ���i �dq�drd d ���ds�dtd d ���du�dvd d ���dw�dxd d ���dy�dzd d ���d{�d|d d ���d}�d}d d ���d~�dd d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ���d��d�d d ����d�d d ��d�d d ��d�d d ��d�d d ��d���Z �d�e�d�< �d�S (� � )� annotations)� TypedDictc @ � e Zd ZU ded< ded< dS )� SPDXLicense�str�id�bool� deprecatedN��__name__� __module__� __qualname__�__annotations__� r r �N/usr/local/CyberPanel/lib/python3.10/site-packages/packaging/licenses/_spdx.pyr � r c @ r )� SPDXExceptionr r r r Nr r r r r r r r z3.25.0�0bsd�0BSDF)r r z 3d-slicer-1.0z 3D-Slicer-1.0�aal�AAL�abstyles�Abstylesz adacore-docz AdaCore-docz adobe-2006z Adobe-2006zadobe-display-postscriptzAdobe-Display-PostScriptz adobe-glyphz Adobe-Glyphz adobe-utopiaz Adobe-Utopia�adsl�ADSLzafl-1.1zAFL-1.1zafl-1.2zAFL-1.2zafl-2.0zAFL-2.0zafl-2.1zAFL-2.1zafl-3.0zAFL-3.0�afmparse�Afmparsezagpl-1.0zAGPL-1.0Tz agpl-1.0-onlyz AGPL-1.0-onlyzagpl-1.0-or-laterzAGPL-1.0-or-laterzagpl-3.0zAGPL-3.0z agpl-3.0-onlyz AGPL-3.0-onlyzagpl-3.0-or-laterzAGPL-3.0-or-later�aladdin�Aladdinz amd-newlibz AMD-newlib�amdplpa�AMDPLPA�aml�AMLz aml-glslangz AML-glslang�ampas�AMPASzantlr-pdzANTLR-PDzantlr-pd-fallbackzANTLR-PD-fallbackzany-osizany-OSIz apache-1.0z Apache-1.0z apache-1.1z Apache-1.1z apache-2.0z Apache-2.0�apafml�APAFMLzapl-1.0zAPL-1.0zapp-s2pzApp-s2pzapsl-1.0zAPSL-1.0zapsl-1.1zAPSL-1.1zapsl-1.2zAPSL-1.2zapsl-2.0zAPSL-2.0z arphic-1999z Arphic-1999z artistic-1.0z Artistic-1.0zartistic-1.0-cl8zArtistic-1.0-cl8zartistic-1.0-perlzArtistic-1.0-Perlz artistic-2.0z Artistic-2.0zaswf-digital-assets-1.0zASWF-Digital-Assets-1.0zaswf-digital-assets-1.1zASWF-Digital-Assets-1.1�baekmuk�Baekmuk�bahyph�Bahyph�barr�Barrzbcrypt-solar-designerzbcrypt-Solar-Designer�beerware�Beerwarezbitstream-charterzBitstream-Charterzbitstream-verazBitstream-Verazbittorrent-1.0zBitTorrent-1.0zbittorrent-1.1zBitTorrent-1.1�blessingz blueoak-1.0.0z BlueOak-1.0.0zboehm-gczBoehm-GC�borceux�Borceuxzbrian-gladman-2-clausezBrian-Gladman-2-Clausezbrian-gladman-3-clausezBrian-Gladman-3-Clausez bsd-1-clausez BSD-1-Clausez bsd-2-clausez BSD-2-Clausezbsd-2-clause-darwinzBSD-2-Clause-Darwinzbsd-2-clause-first-lineszBSD-2-Clause-first-lineszbsd-2-clause-freebsdzBSD-2-Clause-FreeBSDzbsd-2-clause-netbsdzBSD-2-Clause-NetBSDzbsd-2-clause-patentzBSD-2-Clause-Patentzbsd-2-clause-viewszBSD-2-Clause-Viewsz bsd-3-clausez BSD-3-Clausezbsd-3-clause-acpicazBSD-3-Clause-acpicazbsd-3-clause-attributionzBSD-3-Clause-Attributionzbsd-3-clause-clearzBSD-3-Clause-Clearzbsd-3-clause-flexzBSD-3-Clause-flexzbsd-3-clause-hpzBSD-3-Clause-HPzbsd-3-clause-lbnlzBSD-3-Clause-LBNLzbsd-3-clause-modificationzBSD-3-Clause-Modificationz bsd-3-clause-no-military-licensez BSD-3-Clause-No-Military-Licensez bsd-3-clause-no-nuclear-licensez BSD-3-Clause-No-Nuclear-Licensez$bsd-3-clause-no-nuclear-license-2014z$BSD-3-Clause-No-Nuclear-License-2014z bsd-3-clause-no-nuclear-warrantyz BSD-3-Clause-No-Nuclear-Warrantyzbsd-3-clause-open-mpizBSD-3-Clause-Open-MPIzbsd-3-clause-sunzBSD-3-Clause-Sunz bsd-4-clausez BSD-4-Clausezbsd-4-clause-shortenedzBSD-4-Clause-Shortenedzbsd-4-clause-uczBSD-4-Clause-UCz bsd-4.3renoz BSD-4.3RENOz bsd-4.3tahoez BSD-4.3TAHOEz bsd-advertising-acknowledgementz BSD-Advertising-Acknowledgementz bsd-attribution-hpnd-disclaimerz BSD-Attribution-HPND-disclaimerzbsd-inferno-nettverkzBSD-Inferno-Nettverkzbsd-protectionzBSD-Protectionzbsd-source-beginning-filezBSD-Source-beginning-filezbsd-source-codezBSD-Source-Codez bsd-systemicsz BSD-Systemicszbsd-systemics-w3workszBSD-Systemics-W3Workszbsl-1.0zBSL-1.0zbusl-1.1zBUSL-1.1z bzip2-1.0.5z bzip2-1.0.6z c-uda-1.0z C-UDA-1.0zcal-1.0zCAL-1.0z cal-1.0-combined-work-exceptionz CAL-1.0-Combined-Work-Exception�caldera�Calderazcaldera-no-preamblezCaldera-no-preamble�catharon�Catharonz catosl-1.1z CATOSL-1.1z cc-by-1.0z CC-BY-1.0z cc-by-2.0z CC-BY-2.0z cc-by-2.5z CC-BY-2.5z cc-by-2.5-auz CC-BY-2.5-AUz cc-by-3.0z CC-BY-3.0z cc-by-3.0-atz CC-BY-3.0-ATz cc-by-3.0-auz CC-BY-3.0-AUz cc-by-3.0-dez CC-BY-3.0-DEz cc-by-3.0-igoz CC-BY-3.0-IGOz cc-by-3.0-nlz CC-BY-3.0-NLz cc-by-3.0-usz CC-BY-3.0-USz cc-by-4.0z CC-BY-4.0z cc-by-nc-1.0z CC-BY-NC-1.0z cc-by-nc-2.0z CC-BY-NC-2.0z cc-by-nc-2.5z CC-BY-NC-2.5z cc-by-nc-3.0z CC-BY-NC-3.0zcc-by-nc-3.0-dezCC-BY-NC-3.0-DEz cc-by-nc-4.0z CC-BY-NC-4.0zcc-by-nc-nd-1.0zCC-BY-NC-ND-1.0zcc-by-nc-nd-2.0zCC-BY-NC-ND-2.0zcc-by-nc-nd-2.5zCC-BY-NC-ND-2.5zcc-by-nc-nd-3.0zCC-BY-NC-ND-3.0zcc-by-nc-nd-3.0-dezCC-BY-NC-ND-3.0-DEzcc-by-nc-nd-3.0-igozCC-BY-NC-ND-3.0-IGOzcc-by-nc-nd-4.0zCC-BY-NC-ND-4.0zcc-by-nc-sa-1.0zCC-BY-NC-SA-1.0zcc-by-nc-sa-2.0zCC-BY-NC-SA-2.0zcc-by-nc-sa-2.0-dezCC-BY-NC-SA-2.0-DEzcc-by-nc-sa-2.0-frzCC-BY-NC-SA-2.0-FRzcc-by-nc-sa-2.0-ukzCC-BY-NC-SA-2.0-UKzcc-by-nc-sa-2.5zCC-BY-NC-SA-2.5zcc-by-nc-sa-3.0zCC-BY-NC-SA-3.0zcc-by-nc-sa-3.0-dezCC-BY-NC-SA-3.0-DEzcc-by-nc-sa-3.0-igozCC-BY-NC-SA-3.0-IGOzcc-by-nc-sa-4.0zCC-BY-NC-SA-4.0z cc-by-nd-1.0z CC-BY-ND-1.0z cc-by-nd-2.0z CC-BY-ND-2.0z cc-by-nd-2.5z CC-BY-ND-2.5z cc-by-nd-3.0z CC-BY-ND-3.0zcc-by-nd-3.0-dezCC-BY-ND-3.0-DEz cc-by-nd-4.0z CC-BY-ND-4.0z cc-by-sa-1.0z CC-BY-SA-1.0z cc-by-sa-2.0z CC-BY-SA-2.0zcc-by-sa-2.0-ukzCC-BY-SA-2.0-UKzcc-by-sa-2.1-jpzCC-BY-SA-2.1-JPz cc-by-sa-2.5z CC-BY-SA-2.5z cc-by-sa-3.0z CC-BY-SA-3.0zcc-by-sa-3.0-atzCC-BY-SA-3.0-ATzcc-by-sa-3.0-dezCC-BY-SA-3.0-DEzcc-by-sa-3.0-igozCC-BY-SA-3.0-IGOz cc-by-sa-4.0z CC-BY-SA-4.0zcc-pddczCC-PDDCzcc0-1.0zCC0-1.0zcddl-1.0zCDDL-1.0zcddl-1.1zCDDL-1.1zcdl-1.0zCDL-1.0zcdla-permissive-1.0zCDLA-Permissive-1.0zcdla-permissive-2.0zCDLA-Permissive-2.0zcdla-sharing-1.0zCDLA-Sharing-1.0z cecill-1.0z CECILL-1.0z cecill-1.1z CECILL-1.1z cecill-2.0z CECILL-2.0z cecill-2.1z CECILL-2.1zcecill-bzCECILL-Bzcecill-czCECILL-Cz cern-ohl-1.1z CERN-OHL-1.1z cern-ohl-1.2z CERN-OHL-1.2zcern-ohl-p-2.0zCERN-OHL-P-2.0zcern-ohl-s-2.0zCERN-OHL-S-2.0zcern-ohl-w-2.0zCERN-OHL-W-2.0�cfitsio�CFITSIOz check-cvs�checkmk� clartistic� ClArtistic�clips�Clipszcmu-machzCMU-Machzcmu-mach-nodoczCMU-Mach-nodocz cnri-jythonz CNRI-Jythonz cnri-pythonz CNRI-Pythonzcnri-python-gpl-compatiblezCNRI-Python-GPL-Compatiblezcoil-1.0zCOIL-1.0zcommunity-spec-1.0zCommunity-Spec-1.0z condor-1.1z Condor-1.1zcopyleft-next-0.3.0zcopyleft-next-0.3.1zcornell-lossless-jpegzCornell-Lossless-JPEGzcpal-1.0zCPAL-1.0zcpl-1.0zCPL-1.0z cpol-1.02z CPOL-1.02�cronyx�Cronyx� crossword� Crossword�crystalstacker�CrystalStackerz cua-opl-1.0z CUA-OPL-1.0�cube�Cube�curlzcve-touz d-fsl-1.0z D-FSL-1.0z dec-3-clausez DEC-3-Clause�diffmarkz dl-de-by-2.0z DL-DE-BY-2.0zdl-de-zero-2.0zDL-DE-ZERO-2.0�doc�DOCzdocbook-schemazDocBook-Schemaz docbook-xmlz DocBook-XML�dotseqn�Dotseqnzdrl-1.0zDRL-1.0zdrl-1.1zDRL-1.1�dsdp�DSDP�dtoa�dvipdfmzecl-1.0zECL-1.0zecl-2.0zECL-2.0zecos-2.0zeCos-2.0zefl-1.0zEFL-1.0zefl-2.0zEFL-2.0�egenix�eGenixz elastic-2.0z Elastic-2.0�entessa�Entessa�epics�EPICSzepl-1.0zEPL-1.0zepl-2.0zEPL-2.0z erlpl-1.1z ErlPL-1.1z etalab-2.0� eudatagrid� EUDatagridzeupl-1.0zEUPL-1.0zeupl-1.1zEUPL-1.1zeupl-1.2zEUPL-1.2�eurosym�Eurosym�fair�Fair�fbm�FBMzfdk-aaczFDK-AACzferguson-twofishzFerguson-Twofishz frameworx-1.0z Frameworx-1.0z freebsd-docz FreeBSD-DOC� freeimage� FreeImage�fsfap�FSFAPz fsfap-no-warranty-disclaimerz FSFAP-no-warranty-disclaimer�fsful�FSFUL�fsfullr�FSFULLR� fsfullrwd� FSFULLRWD�ftl�FTL�furuseth�Furuseth�fwlwzgcr-docszGCR-docs�gd�GDzgfdl-1.1zGFDL-1.1zgfdl-1.1-invariants-onlyzGFDL-1.1-invariants-onlyz gfdl-1.1-invariants-or-laterz GFDL-1.1-invariants-or-laterzgfdl-1.1-no-invariants-onlyzGFDL-1.1-no-invariants-onlyz gfdl-1.1-no-invariants-or-laterz GFDL-1.1-no-invariants-or-laterz gfdl-1.1-onlyz GFDL-1.1-onlyzgfdl-1.1-or-laterzGFDL-1.1-or-laterzgfdl-1.2zGFDL-1.2zgfdl-1.2-invariants-onlyzGFDL-1.2-invariants-onlyz gfdl-1.2-invariants-or-laterz GFDL-1.2-invariants-or-laterzgfdl-1.2-no-invariants-onlyzGFDL-1.2-no-invariants-onlyz gfdl-1.2-no-invariants-or-laterz GFDL-1.2-no-invariants-or-laterz gfdl-1.2-onlyz GFDL-1.2-onlyzgfdl-1.2-or-laterzGFDL-1.2-or-laterzgfdl-1.3zGFDL-1.3zgfdl-1.3-invariants-onlyzGFDL-1.3-invariants-onlyz gfdl-1.3-invariants-or-laterz GFDL-1.3-invariants-or-laterzgfdl-1.3-no-invariants-onlyzGFDL-1.3-no-invariants-onlyz gfdl-1.3-no-invariants-or-laterz GFDL-1.3-no-invariants-or-laterz gfdl-1.3-onlyz GFDL-1.3-onlyzgfdl-1.3-or-laterzGFDL-1.3-or-later�giftware�Giftware�gl2ps�GL2PS�glide�Glide�glulxe�Glulxe�glwtpl�GLWTPL�gnuplotzgpl-1.0zGPL-1.0zgpl-1.0+zGPL-1.0+z gpl-1.0-onlyz GPL-1.0-onlyzgpl-1.0-or-laterzGPL-1.0-or-laterzgpl-2.0zGPL-2.0zgpl-2.0+zGPL-2.0+z gpl-2.0-onlyz GPL-2.0-onlyzgpl-2.0-or-laterzGPL-2.0-or-laterz gpl-2.0-with-autoconf-exceptionz GPL-2.0-with-autoconf-exceptionz gpl-2.0-with-bison-exceptionz GPL-2.0-with-bison-exceptionz gpl-2.0-with-classpath-exceptionz GPL-2.0-with-classpath-exceptionzgpl-2.0-with-font-exceptionzGPL-2.0-with-font-exceptionzgpl-2.0-with-gcc-exceptionzGPL-2.0-with-GCC-exceptionzgpl-3.0zGPL-3.0zgpl-3.0+zGPL-3.0+z gpl-3.0-onlyz GPL-3.0-onlyzgpl-3.0-or-laterzGPL-3.0-or-laterz gpl-3.0-with-autoconf-exceptionz GPL-3.0-with-autoconf-exceptionzgpl-3.0-with-gcc-exceptionzGPL-3.0-with-GCC-exceptionz graphics-gemsz Graphics-Gemsz gsoap-1.3bz gSOAP-1.3b�gtkbook�gutmann�Gutmann� haskellreport� HaskellReport�hdparm�hidapi�HIDAPIzhippocratic-2.1zHippocratic-2.1zhp-1986zHP-1986zhp-1989zHP-1989�hpnd�HPNDzhpnd-deczHPND-DECzhpnd-doczHPND-docz hpnd-doc-sellz HPND-doc-sellzhpnd-export-uszHPND-export-USz hpnd-export-us-acknowledgementz HPND-export-US-acknowledgementzhpnd-export-us-modifyzHPND-export-US-modifyzhpnd-export2-uszHPND-export2-USzhpnd-fenneberg-livingstonzHPND-Fenneberg-Livingstonzhpnd-inria-imagzHPND-INRIA-IMAGz hpnd-intelz HPND-Intelzhpnd-kevlin-henneyzHPND-Kevlin-Henneyzhpnd-markus-kuhnzHPND-Markus-Kuhnz hpnd-merchantability-variantz HPND-merchantability-variantzhpnd-mit-disclaimerzHPND-MIT-disclaimerz hpnd-netrekz HPND-Netrekz hpnd-pbmplusz HPND-Pbmplusz hpnd-sell-mit-disclaimer-xserverz HPND-sell-MIT-disclaimer-xserverzhpnd-sell-regexprzHPND-sell-regexprzhpnd-sell-variantzHPND-sell-variantz hpnd-sell-variant-mit-disclaimerz HPND-sell-variant-MIT-disclaimerz$hpnd-sell-variant-mit-disclaimer-revz$HPND-sell-variant-MIT-disclaimer-revzhpnd-uczHPND-UCzhpnd-uc-export-uszHPND-UC-export-US�htmltidy�HTMLTIDYzibm-pibszIBM-pibs�icu�ICUziec-code-components-eulazIEC-Code-Components-EULA�ijg�IJGz ijg-shortz IJG-short� imagemagick� ImageMagick�imatix�iMatix�imlib2�Imlib2zinfo-zipzInfo-ZIPz inner-net-2.0z Inner-Net-2.0�intel�Intelz intel-acpiz Intel-ACPIz interbase-1.0z Interbase-1.0�ipa�IPAzipl-1.0zIPL-1.0�isc�ISCz isc-veillardz ISC-Veillard�jam�Jamz jasper-2.0z JasPer-2.0z jpl-imagez JPL-image�jpnic�JPNIC�json�JSON�kastrup�Kastrup�kazlib�Kazlibz knuth-ctanz Knuth-CTANzlal-1.2zLAL-1.2zlal-1.3zLAL-1.3�latex2e�Latex2ezlatex2e-translated-noticezLatex2e-translated-notice� leptonica� Leptonicazlgpl-2.0zLGPL-2.0z lgpl-2.0+z LGPL-2.0+z lgpl-2.0-onlyz LGPL-2.0-onlyzlgpl-2.0-or-laterzLGPL-2.0-or-laterzlgpl-2.1zLGPL-2.1z lgpl-2.1+z LGPL-2.1+z lgpl-2.1-onlyz LGPL-2.1-onlyzlgpl-2.1-or-laterzLGPL-2.1-or-laterzlgpl-3.0zLGPL-3.0z lgpl-3.0+z LGPL-3.0+z lgpl-3.0-onlyz LGPL-3.0-onlyzlgpl-3.0-or-laterzLGPL-3.0-or-later�lgpllr�LGPLLR�libpng�Libpngz libpng-2.0zlibselinux-1.0�libtiffzlibutil-david-nugentzlibutil-David-Nugentz liliq-p-1.1z LiLiQ-P-1.1z liliq-r-1.1z LiLiQ-R-1.1zliliq-rplus-1.1zLiLiQ-Rplus-1.1zlinux-man-pages-1-parazLinux-man-pages-1-parazlinux-man-pages-copyleftzLinux-man-pages-copyleftz linux-man-pages-copyleft-2-paraz Linux-man-pages-copyleft-2-paraz linux-man-pages-copyleft-varz Linux-man-pages-copyleft-varz linux-openibz Linux-OpenIB�loop�LOOPz lpd-documentz LPD-documentzlpl-1.0zLPL-1.0zlpl-1.02zLPL-1.02zlppl-1.0zLPPL-1.0zlppl-1.1zLPPL-1.1zlppl-1.2zLPPL-1.2z lppl-1.3az LPPL-1.3az lppl-1.3cz LPPL-1.3c�lsofzlucida-bitmap-fontszLucida-Bitmap-Fontszlzma-sdk-9.11-to-9.20zLZMA-SDK-9.11-to-9.20z lzma-sdk-9.22z LZMA-SDK-9.22zmackerras-3-clausezMackerras-3-Clausez!mackerras-3-clause-acknowledgmentz!Mackerras-3-Clause-acknowledgment�magaz�mailprio� makeindex� MakeIndexzmartin-birgmeierzMartin-Birgmeierzmcphee-slideshowzMcPhee-slideshow�metamail�minpack�Minpack�miros�MirOS�mit�MITzmit-0zMIT-0zmit-advertisingzMIT-advertisingzmit-cmuzMIT-CMUzmit-ennazMIT-ennazmit-fehzMIT-fehz mit-festivalz MIT-Festivalzmit-khronos-oldzMIT-Khronos-oldzmit-modern-variantzMIT-Modern-Variantzmit-open-groupzMIT-open-groupz mit-testregexz MIT-testregexzmit-wuzMIT-Wu�mitnfa�MITNFA�mmixware�MMIXware�motosoto�Motosotozmpeg-ssgzMPEG-SSGzmpi-permissive�mpich2zmpl-1.0zMPL-1.0zmpl-1.1zMPL-1.1zmpl-2.0zMPL-2.0z mpl-2.0-no-copyleft-exceptionz MPL-2.0-no-copyleft-exception�mpluszms-lplzMS-LPLzms-plzMS-PLzms-rlzMS-RL�mtll�MTLLz mulanpsl-1.0z MulanPSL-1.0z mulanpsl-2.0z MulanPSL-2.0�multics�Multics�mup�Mupz naist-2003z NAIST-2003znasa-1.3zNASA-1.3�naumen�Naumenznbpl-1.0zNBPL-1.0zncbi-pdzNCBI-PDz ncgl-uk-2.0z NCGL-UK-2.0�ncl�NCL�ncsa�NCSAznet-snmpzNet-SNMP�netcdf�NetCDF�newsletr�Newsletr�ngpl�NGPLz nicta-1.0z NICTA-1.0znist-pdzNIST-PDznist-pd-fallbackzNIST-PD-fallbackz nist-softwarez NIST-Softwareznlod-1.0zNLOD-1.0znlod-2.0zNLOD-2.0�nlpl�NLPL�nokia�Nokia�nosl�NOSL�noweb�Nowebznpl-1.0zNPL-1.0znpl-1.1zNPL-1.1z nposl-3.0z NPOSL-3.0�nrl�NRL�ntp�NTPzntp-0zNTP-0�nunit�Nunitz o-uda-1.0z O-UDA-1.0�oar�OARzocct-plzOCCT-PLzoclc-2.0zOCLC-2.0zodbl-1.0zODbL-1.0z odc-by-1.0z ODC-By-1.0�offis�OFFISzofl-1.0zOFL-1.0zofl-1.0-no-rfnzOFL-1.0-no-RFNz ofl-1.0-rfnz OFL-1.0-RFNzofl-1.1zOFL-1.1zofl-1.1-no-rfnzOFL-1.1-no-RFNz ofl-1.1-rfnz OFL-1.1-RFNzogc-1.0zOGC-1.0zogdl-taiwan-1.0zOGDL-Taiwan-1.0zogl-canada-2.0zOGL-Canada-2.0z ogl-uk-1.0z OGL-UK-1.0z ogl-uk-2.0z OGL-UK-2.0z ogl-uk-3.0z OGL-UK-3.0�ogtsl�OGTSLz oldap-1.1z OLDAP-1.1z oldap-1.2z OLDAP-1.2z oldap-1.3z OLDAP-1.3z oldap-1.4z OLDAP-1.4z oldap-2.0z OLDAP-2.0z oldap-2.0.1z OLDAP-2.0.1z oldap-2.1z OLDAP-2.1z oldap-2.2z OLDAP-2.2z oldap-2.2.1z OLDAP-2.2.1z oldap-2.2.2z OLDAP-2.2.2z oldap-2.3z OLDAP-2.3z oldap-2.4z OLDAP-2.4z oldap-2.5z OLDAP-2.5z oldap-2.6z OLDAP-2.6z oldap-2.7z OLDAP-2.7z oldap-2.8z OLDAP-2.8zolfl-1.3zOLFL-1.3�oml�OMLz openpbs-2.3z OpenPBS-2.3�openssl�OpenSSLzopenssl-standalonezOpenSSL-standalone� openvision� OpenVisionzopl-1.0zOPL-1.0z opl-uk-3.0z OPL-UK-3.0z opubl-1.0z OPUBL-1.0z oset-pl-2.1z OSET-PL-2.1zosl-1.0zOSL-1.0zosl-1.1zOSL-1.1zosl-2.0zOSL-2.0zosl-2.1zOSL-2.1zosl-3.0zOSL-3.0�padl�PADLz parity-6.0.0z Parity-6.0.0z parity-7.0.0z Parity-7.0.0zpddl-1.0zPDDL-1.0zphp-3.0zPHP-3.0zphp-3.01zPHP-3.01�pixar�Pixar�pkgconf�plexus�Plexus� pnmstitchz polyform-noncommercial-1.0.0z PolyForm-Noncommercial-1.0.0z polyform-small-business-1.0.0z PolyForm-Small-Business-1.0.0� postgresql� PostgreSQL�ppl�PPLzpsf-2.0zPSF-2.0�psfrag�psutilsz python-2.0z Python-2.0z python-2.0.1z Python-2.0.1z python-ldap�qhull�Qhullzqpl-1.0zQPL-1.0zqpl-1.0-inria-2004zQPL-1.0-INRIA-2004�radvd�rdisc�Rdiscz rhecos-1.1z RHeCos-1.1zrpl-1.1zRPL-1.1zrpl-1.5zRPL-1.5zrpsl-1.0zRPSL-1.0zrsa-mdzRSA-MD�rscpl�RSCPL�ruby�Rubyzruby-ptyzRuby-ptyzsax-pdzSAX-PDz sax-pd-2.0z SAX-PD-2.0�saxpath�Saxpath�scea�SCEA� schemereport� SchemeReport�sendmail�Sendmailz sendmail-8.23z Sendmail-8.23z sgi-b-1.0z SGI-B-1.0z sgi-b-1.1z SGI-B-1.1z sgi-b-2.0z SGI-B-2.0z sgi-openglz SGI-OpenGL�sgp4�SGP4zshl-0.5zSHL-0.5zshl-0.51zSHL-0.51z simpl-2.0z SimPL-2.0�sissl�SISSLz sissl-1.2z SISSL-1.2�sl�SL� sleepycat� Sleepycat�smlnj�SMLNJ�smppl�SMPPL�snia�SNIA�snprintf� softsurfer� softSurfer�soundex�Soundexz spencer-86z Spencer-86z spencer-94z Spencer-94z spencer-99z Spencer-99zspl-1.0zSPL-1.0z ssh-keyscanz ssh-opensshz SSH-OpenSSHz ssh-shortz SSH-shortzssleay-standalonezSSLeay-standalonezsspl-1.0zSSPL-1.0z standardml-njz StandardML-NJzsugarcrm-1.1.3zSugarCRM-1.1.3zsun-pppzSun-PPPz sun-ppp-2000z Sun-PPP-2000�sunpro�SunPro�swl�SWL�swrule�symlinks�Symlinksz tapr-ohl-1.0z TAPR-OHL-1.0�tcl�TCLz tcp-wrappersz TCP-wrappers� termreadkey� TermReadKeyz tgppl-1.0z TGPPL-1.0�threeparttable�tmate�TMatez torque-1.1z TORQUE-1.1�tosl�TOSL�tpdl�TPDLztpl-1.0zTPL-1.0�ttwl�TTWL�ttyp0�TTYP0z tu-berlin-1.0z TU-Berlin-1.0z tu-berlin-2.0z TU-Berlin-2.0zubuntu-font-1.0zUbuntu-font-1.0�ucar�UCARzucl-1.0zUCL-1.0�ulemz umich-meritz UMich-Meritz unicode-3.0z Unicode-3.0zunicode-dfs-2015zUnicode-DFS-2015zunicode-dfs-2016zUnicode-DFS-2016z unicode-touz Unicode-TOU� unixcrypt� UnixCrypt� unlicense� Unlicensezupl-1.0zUPL-1.0zurt-rlezURT-RLE�vim�Vim�vostrom�VOSTROMzvsl-1.0zVSL-1.0�w3c�W3Cz w3c-19980720z W3C-19980720z w3c-20150513z W3C-20150513�w3mz watcom-1.0z Watcom-1.0zwidget-workshopzWidget-Workshop�wsuipa�Wsuipa�wtfpl�WTFPL� wxwindows� wxWindows�x11�X11z$x11-distribute-modifications-variantz$X11-distribute-modifications-variantz x11-swappedz X11-swappedz xdebug-1.03z Xdebug-1.03�xerox�Xerox�xfig�Xfigz xfree86-1.1z XFree86-1.1�xinetdzxkeyboard-config-zinovievzxkeyboard-config-Zinoviev�xlock�xnet�Xnet�xpp�xskat�XSkat�xzoomzypl-1.0zYPL-1.0zypl-1.1zYPL-1.1�zed�Zed�zeeff�Zeeffzzend-2.0zZend-2.0z zimbra-1.3z Zimbra-1.3z zimbra-1.4z Zimbra-1.4�zlib�Zlibzzlib-acknowledgementzZPL-1.1zZPL-2.0zZPL-2.1)zzpl-1.1zzpl-2.0zzpl-2.1zdict[str, SPDXLicense]�LICENSESz 389-exceptionzasterisk-exceptionzAsterisk-exceptionz$asterisk-linking-protocols-exceptionz$Asterisk-linking-protocols-exceptionzautoconf-exception-2.0zAutoconf-exception-2.0zautoconf-exception-3.0zAutoconf-exception-3.0zautoconf-exception-genericzAutoconf-exception-genericz autoconf-exception-generic-3.0z Autoconf-exception-generic-3.0zautoconf-exception-macrozAutoconf-exception-macrozbison-exception-1.24zBison-exception-1.24zbison-exception-2.2zBison-exception-2.2zbootloader-exceptionzBootloader-exceptionzclasspath-exception-2.0zClasspath-exception-2.0zclisp-exception-2.0zCLISP-exception-2.0z cryptsetup-openssl-exceptionz cryptsetup-OpenSSL-exceptionzdigirule-foss-exceptionzDigiRule-FOSS-exceptionzecos-exception-2.0zeCos-exception-2.0z erlang-otp-linking-exceptionzfawkes-runtime-exceptionzFawkes-Runtime-exceptionzfltk-exceptionzFLTK-exceptionz fmt-exceptionzfont-exception-2.0zFont-exception-2.0zfreertos-exception-2.0zgcc-exception-2.0zGCC-exception-2.0zgcc-exception-2.0-notezGCC-exception-2.0-notezgcc-exception-3.1zGCC-exception-3.1zgmsh-exceptionzGmsh-exceptionzgnat-exceptionzGNAT-exceptionzgnome-examples-exceptionzGNOME-examples-exceptionzgnu-compiler-exceptionzGNU-compiler-exceptionzgnu-javamail-exceptionzgpl-3.0-interface-exceptionzGPL-3.0-interface-exceptionzgpl-3.0-linking-exceptionzGPL-3.0-linking-exceptionz gpl-3.0-linking-source-exceptionz GPL-3.0-linking-source-exceptionz gpl-cc-1.0z GPL-CC-1.0zgstreamer-exception-2005zGStreamer-exception-2005zgstreamer-exception-2008zGStreamer-exception-2008zi2p-gpl-java-exceptionzkicad-libraries-exceptionzKiCad-libraries-exceptionzlgpl-3.0-linking-exceptionzLGPL-3.0-linking-exceptionzlibpri-openh323-exceptionzlibpri-OpenH323-exceptionzlibtool-exceptionzLibtool-exceptionzlinux-syscall-notezLinux-syscall-note�llgpl�LLGPLzllvm-exceptionzLLVM-exceptionzlzma-exceptionzLZMA-exceptionz mif-exceptionznokia-qt-exception-1.1zNokia-Qt-exception-1.1z ocaml-lgpl-linking-exceptionz OCaml-LGPL-linking-exceptionzocct-exception-1.0zOCCT-exception-1.0z openjdk-assembly-exception-1.0z OpenJDK-assembly-exception-1.0zopenvpn-openssl-exceptionzpcre2-exceptionzPCRE2-exceptionz!ps-or-pdf-font-exception-20170817z!PS-or-PDF-font-exception-20170817z qpl-1.0-inria-2004-exceptionz QPL-1.0-INRIA-2004-exceptionzqt-gpl-exception-1.0zQt-GPL-exception-1.0zqt-lgpl-exception-1.1zQt-LGPL-exception-1.1zqwt-exception-1.0zQwt-exception-1.0zromic-exceptionzrrdtool-floss-exception-2.0zRRDtool-FLOSS-exception-2.0zsane-exceptionzSANE-exceptionzshl-2.0zSHL-2.0zshl-2.1zSHL-2.1zstunnel-exceptionz swi-exceptionz SWI-exceptionzswift-exceptionzSwift-exceptionztexinfo-exceptionzTexinfo-exceptionzu-boot-exception-2.0zubdl-exceptionzUBDL-exceptionz Universal-FOSS-exception-1.0�vsftpd-openssl-exceptionzWxWindows-exception-3.1�x11vnc-openssl-exception)z universal-foss-exception-1.0r] zwxwindows-exception-3.1r^ zdict[str, SPDXException]� EXCEPTIONSN) � __future__r �typingr r r �VERSIONrZ r r_ r r r r �<module> s�! � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � !� "� #� $� %� &� '� (� )� *� +� ,� -� .� /� 0� 1� 2� 3� 4� 5� 6� 7� 8� 9� :� ;� <� =� >� ?� @� A� B� C� D� E� F� G� H� I� J� K� L� M� N� O� P� Q� R� S� T� U� V� W� X� Y� Z� [� \� ]� ^� _� `� a� b� c� d� e� f� g� h� i� j� k� l� m� n� o� p� q� r� s� t� u� v� w� x� y� z� {� |�}�~�� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� ! �� " �� # �� $ �� % �� & �� ' �� ( �� ) �� * �� + �� , �� - �� . �� / �� 0 �� 1 �� 2 �� 3 �� 4 �� 5 �� 6 �� 7 �� 8 �� 9 �� : �� ; �� < �� = �� > �� ? �� @ �� A �� B �� C �� D �� E �� F �� G �� H �� I �� J �� K �� L �� M �� N �� O �� P �� Q �� R �� S �� T �� U �� V �� W �� X �� Y �� Z �� [ �� \ �� ] �� ^ �� _ �� ` �� a �� b �� c �� d �� e �� f �� g �� h �� i �� j �� k �� l �� m �� n �� o �� p �� q �� r �� s �� t �� u �� v �� w �� x �� y �� z �� { �� | �� } �� ~ �� �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� � �� ! � �� " � �� # � �� $ � �� % � �� & � �� ' � �� ( � �� ) � �� * � �� + � �� , � �� - � �� . � �� / � �� 0 � �� 1 � �� 2 � �� 3 � �� 4 � �� 5 � �� 6 � �� 7 � �� 8 � �� 9 � �� : � �� ; � �� < � �� = � �� > � �� ? � �� @ � �� A � �� B � �� C � �� D � �� E � �� F � �� G � �� H � �� I � �� J � �� K � �� L � �� M � �� N � �� O � �� P � �� Q � �� R � �� S � �� T � �� U � �� V � �� W � �� X � �� Y � �� Z � �� [ � �� \ � �� ] � �� ^ � �� _ � �� ` � �� a � �� b � �� c � �� d � �� e � �� f � �� g � �� h � �� i � �� j � �� k � �� l � �� m � �� n � �� o � �� p � �� q � �� r � �� s � �� t � �� u � �� v � �� w � �� x � �� y � �� z � �� { � �� | � �� } � �� ~ � �� � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� � � �� ! � � �� " � � �� # � � �� $ � � �� % � � �� & � � �� ' � � �� ( � � �� ) � � �� * � � �� + � � �� , � � �� - � � �� . � � �� / � � �� 0 � � �� 1 � � �� 2 � � �� 3 � � �� 4 � � �� 5 � � �� 6 � � �� 7 � � �� 8 � � �� 9 � � �� : � � �� ; � � �� < � � �� = � � �� > � � �� ? � � �� @ � � �� A � � �� B � � �� C � � �� D � � �� E � � �� F � � �� G � � �� H � � �� I � � �� J � � �� K � � �� L � � �� M � � �� N � � �� O � � �� P � � �� Q � � �� R � � �� S � � �� T � � �� U � � �� V � � �� W � � �� X � � �� Y � � �� Z � � �� [ � � �� \ � � �� ] � � �� ^ � � �� _ � � �� ` � � �� a � � �� b � � �� c � � �� d � � �� e � � �� f � � �� g � � �� h � � �� i � � �� j � � �� k � � �� l � � �� m � � �� n � � �� o � � �� p � � �� q � � �� r � � �� s � � �� t � � �� u � � �� v � � �� w � � �� x � � �� y � � �� z � � �� { � � �� | � � �� } � � �� ~ � � �� � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� � � � �� ! � � � �� " � � � �� # � � � �� $ � � � �� % � � � �� & � � � �� ' � � � �� ( � � � �� ) � � � �� * � � � �� + � � � �� , � � � �� - � � � �� . � � � �� / � � � �� 0 � � � �� 1 � � � �� 2 � � � �� 3 � � � �� 4 � � � �� 5 � � � �� 6 � � � �� 7 � � � �� 8 � � � �� 9 � � � �� : � � � �� ; � � � �� < � � � �� = � � � �� > � � � �� ? � � � �� @ � � � �� A � � � �� B � � � �� C � � � �� D � � � �� E � � � �� F � � � �� G � � � �� H � � � �� I � � � �� J � � � �� K � � � �� L � � � �� M � � � �� N � � � �� O � � � �� P � � � �� Q � � � �� R � � � �� S � � � �� T � � � �� U � � � �� V � � � �� W � � � �� X � � � �� Y � � � �� Z � � � �� [ � � � �� \ � � � �� ] � � � �� ^ � � � �� _ � � � �� ` � � � �� a � � � �� b � � � �� c � � � �� d � � � �� e � � � �� f � � � �� g � � � �� h � � � �� i � � � �� j � � � �� k � � � �� l � � � �� m � � � �� n � � � �� o � � � �� p � � � �� q � � � �� r � � � �� s � � � �� t � � � �� u � � � �� v � � � �� w � � � �� x � � � �� y � � � �� z � � � �� { � � � �� | � � � �� } � � � �� ~ � � � �� � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� � � � � �� "�������� � � � � ��������������� � � � � �!�"�#�$�%�&�'�(�)�*�+�,�-�.�/�0�1�2�3�4�5�6�7�8�9�:�;�<�=�>�?�@�A�B�C�D� E � LICENSE.BSD 0000644 00000002500 15030124065 0006151 0 ustar 00 Copyright (c) Donald Stufft and individual contributors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. LICENSE.APACHE 0000644 00000023676 15030124065 0006503 0 ustar 00 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS LICENSE 0000644 00000000305 15030124065 0005543 0 ustar 00 This software is made available under the terms of *either* of the licenses found in LICENSE.APACHE or LICENSE.BSD. Contributions to this software is made under the terms of *both* these licenses.
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.03 |
proxy
|
phpinfo
|
Settings