FM / packaging

/opt/imunify360/venv/lib/python3.11/site-packages/pip/_vendor/packaging/

/opt/imunify360/venv/lib/python3.11/site-packages/pip/_vendor/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
LICENSE	197	0644	edit dl rm
LICENSE.APACHE	10174	0644	edit dl rm
LICENSE.BSD	1344	0644	edit dl rm
markers.py	17067	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	4395	0644	edit dl rm
specifiers.py	71550	0644	edit dl rm
tags.py	34236	0644	edit dl rm
utils.py	9848	0644	edit dl rm
version.py	38393	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: /opt/imunify360/venv/lib/python3.11/site-packages/pip/_vendor/packaging/errors.py (2680B)

from __future__ import annotations

import contextlib
import dataclasses
import sys
import typing

__all__ = ["ExceptionGroup"]

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

if sys.version_info >= (3, 11):  # pragma: no cover
    from builtins import 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})"

@dataclasses.dataclass
class _ErrorCollector:
    """
    Collect errors into ExceptionGroups.

Used like this:

collector = _ErrorCollector()
        # Add a single exception
        collector.error(ValueError("one"))

# Supports nesting, including combining ExceptionGroups
        with collector.collect():
            raise ValueError("two")
        collector.finalize("Found some errors")

Since making a collector and then calling finalize later is a common pattern,
    a convenience method ``on_exit`` is provided.
    """

errors: list[Exception] = dataclasses.field(default_factory=list, init=False)

def finalize(self, msg: str) -> None:
        """Raise a group exception if there are any errors."""
        if self.errors:
            raise ExceptionGroup(msg, self.errors)

@contextlib.contextmanager
    def on_exit(self, msg: str) -> typing.Generator[_ErrorCollector, None, None]:
        """
        Calls finalize if no uncollected errors were present.

Uncollected errors are raised normally.
        """
        yield self
        self.finalize(msg)

@contextlib.contextmanager
    def collect(self, *err_cls: type[Exception]) -> typing.Generator[None, None, None]:
        """
        Context manager to collect errors into the error list.

Must be inside loops, as only one error can be collected at a time.
        """
        error_classes = err_cls or (Exception,)
        try:
            yield
        except ExceptionGroup as error:
            self.errors.extend(error.exceptions)
        except error_classes as error:
            self.errors.append(error)

def error(
        self,
        error: Exception,
    ) -> None:
        """Add an error to the list."""
        self.errors.append(error)

from __future__ import annotations import contextlib import dataclasses import sys import typing __all__ = ["ExceptionGroup"] def __dir__() -> list[str]: return __all__ if sys.version_info >= (3, 11): # pragma: no cover from builtins import 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})" @dataclasses.dataclass class _ErrorCollector: """ Collect errors into ExceptionGroups. Used like this: collector = _ErrorCollector() # Add a single exception collector.error(ValueError("one")) # Supports nesting, including combining ExceptionGroups with collector.collect(): raise ValueError("two") collector.finalize("Found some errors") Since making a collector and then calling finalize later is a common pattern, a convenience method ``on_exit`` is provided. """ errors: list[Exception] = dataclasses.field(default_factory=list, init=False) def finalize(self, msg: str) -> None: """Raise a group exception if there are any errors.""" if self.errors: raise ExceptionGroup(msg, self.errors) @contextlib.contextmanager def on_exit(self, msg: str) -> typing.Generator[_ErrorCollector, None, None]: """ Calls finalize if no uncollected errors were present. Uncollected errors are raised normally. """ yield self self.finalize(msg) @contextlib.contextmanager def collect(self, *err_cls: type[Exception]) -> typing.Generator[None, None, None]: """ Context manager to collect errors into the error list. Must be inside loops, as only one error can be collected at a time. """ error_classes = err_cls or (Exception,) try: yield except ExceptionGroup as error: self.errors.extend(error.exceptions) except error_classes as error: self.errors.append(error) def error( self, error: Exception, ) -> None: """Add an error to the list.""" self.errors.append(error)