FM / packaging

/usr/lib/imh-ultrastack-common/venv/lib/python3.13/site-packages/packaging/

/usr/lib/imh-ultrastack-common/venv/lib/python3.13/site-packages/packaging

Name	Size	Mode	Actions
licenses/	-	0755	rm
__pycache__/	-	0755	rm
dependency_groups.py	10218	0644	edit dl rm
direct_url.py	10917	0644	edit dl rm
errors.py	2680	0644	edit dl rm
markers.py	17055	0644	edit dl rm
metadata.py	38770	0644	edit dl rm
py.typed	0	0644	edit dl rm
pylock.py	33890	0644	edit dl rm
requirements.py	4383	0644	edit dl rm
specifiers.py	71514	0644	edit dl rm
tags.py	34224	0644	edit dl rm
utils.py	9848	0644	edit dl rm
version.py	38369	0644	edit dl rm
_elffile.py	3211	0644	edit dl rm
_manylinux.py	9559	0644	edit dl rm
_musllinux.py	2707	0644	edit dl rm
_parser.py	11698	0644	edit dl rm
_structures.py	1109	0644	edit dl rm
_tokenizer.py	5391	0644	edit dl rm
__init__.py	494	0644	edit dl rm

Edit: /usr/lib/imh-ultrastack-common/venv/lib/python3.13/site-packages/packaging/requirements.py (4383B)

# 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 __future__ import annotations

from typing import Iterator

from ._parser import parse_requirement as _parse_requirement
from ._tokenizer import ParserSyntaxError
from .markers import Marker, _normalize_extra_values
from .specifiers import SpecifierSet
from .utils import canonicalize_name

__all__ = [
    "InvalidRequirement",
    "Requirement",
]

def __dir__() -> list[str]:
    return __all__

class InvalidRequirement(ValueError):
    """
    An invalid requirement was found, users should refer to PEP 508.
    """

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.

Instances are safe to serialize with :mod:`pickle`. They use a stable
    format so the same pickle can be loaded in future packaging releases.

.. versionchanged:: 26.2

Added a stable pickle format. Pickles created with packaging 26.2+ can
        be unpickled with future releases.  Backward compatibility with pickles
        from packaging < 26.2 is supported but may be removed in a future
        release.
    """

# 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:
            parsed = _parse_requirement(requirement_string)
        except ParserSyntaxError as e:
            raise InvalidRequirement(str(e)) from e

self.name: str = parsed.name
        self.url: str | None = parsed.url or None
        self.extras: set[str] = set(parsed.extras or [])
        self.specifier: SpecifierSet = SpecifierSet(parsed.specifier)
        self.marker: Marker | None = None
        if parsed.marker is not None:
            self.marker = Marker.__new__(Marker)
            self.marker._markers = _normalize_extra_values(parsed.marker)

def _iter_parts(self, name: str) -> Iterator[str]:
        yield name

if self.extras:
            formatted_extras = ",".join(sorted(self.extras))
            yield f"[{formatted_extras}]"

if self.specifier:
            yield str(self.specifier)

if self.url:
            yield f" @ {self.url}"
            if self.marker:
                yield " "

if self.marker:
            yield f"; {self.marker}"

def __getstate__(self) -> str:
        # Return the requirement string for compactness and stability.
        # Re-parsed on load to reconstruct all fields.
        return str(self)

def __setstate__(self, state: object) -> None:
        if isinstance(state, str):
            # New format (26.2+): just the requirement string.
            try:
                tmp = Requirement(state)
            except InvalidRequirement as exc:
                raise TypeError(f"Cannot restore Requirement from {state!r}") from exc
            self.name = tmp.name
            self.url = tmp.url
            self.extras = tmp.extras
            self.specifier = tmp.specifier
            self.marker = tmp.marker
            return
        if isinstance(state, dict):
            # Old format (packaging <= 26.1, no __slots__): plain __dict__.
            self.__dict__.update(state)
            return
        raise TypeError(f"Cannot restore Requirement from {state!r}")

def __str__(self) -> str:
        return "".join(self._iter_parts(self.name))

def __repr__(self) -> str:
        return f"<{self.__class__.__name__}({str(self)!r})>"

def __hash__(self) -> int:
        return hash(tuple(self._iter_parts(canonicalize_name(self.name))))

def __eq__(self, other: object) -> bool:
        if not isinstance(other, Requirement):
            return NotImplemented

return (
            canonicalize_name(self.name) == canonicalize_name(other.name)
            and self.extras == other.extras
            and self.specifier == other.specifier
            and self.url == other.url
            and self.marker == other.marker
        )

cmd: