File Manager

X7ROOT File Manager

Current Path: /opt/cloudlinux/venv/lib/python3.11/site-packages/_pytest

opt / cloudlinux / venv / lib / python3.11 / site-packages / _pytest /

?? ..
?? __init__.py(356 B)
?? __pycache__
?? _argcomplete.py(3.71 KB)
?? _code
?? _io
?? _py
?? _version.py(160 B)
?? assertion
?? cacheprovider.py(20.89 KB)
?? capture.py(33.92 KB)
?? compat.py(12.89 KB)
?? config
?? debugging.py(13.18 KB)
?? deprecated.py(5.36 KB)
?? doctest.py(25.35 KB)
?? faulthandler.py(3.04 KB)
?? fixtures.py(65.51 KB)
?? freeze_support.py(1.31 KB)
?? helpconfig.py(8.34 KB)
?? hookspec.py(31.79 KB)
?? junitxml.py(25.11 KB)
?? legacypath.py(16.53 KB)
?? logging.py(33.23 KB)
?? main.py(31.73 KB)
?? mark
?? monkeypatch.py(14.51 KB)
?? nodes.py(25.94 KB)
?? nose.py(1.65 KB)
?? outcomes.py(10.02 KB)
?? pastebin.py(3.86 KB)
?? pathlib.py(25.22 KB)
?? py.typed(0 B)
?? pytester.py(60.52 KB)
?? pytester_assertions.py(2.27 KB)
?? python.py(69.49 KB)
?? python_api.py(37.5 KB)
?? python_path.py(709 B)
?? recwarn.py(10.67 KB)
?? reports.py(20.35 KB)
?? runner.py(18.01 KB)
?? scope.py(2.81 KB)
?? setuponly.py(3.18 KB)
?? setupplan.py(1.19 KB)
?? skipping.py(9.96 KB)
?? stash.py(2.98 KB)
?? stepwise.py(4.6 KB)
?? terminal.py(52.25 KB)
?? threadexception.py(2.85 KB)
?? timing.py(375 B)
?? tmpdir.py(11.43 KB)
?? unittest.py(14.46 KB)
?? unraisableexception.py(3.12 KB)
?? warning_types.py(4.37 KB)
?? warnings.py(4.95 KB)

Editing: stash.py

from typing import Any
from typing import cast
from typing import Dict
from typing import Generic
from typing import TypeVar
from typing import Union

__all__ = ["Stash", "StashKey"]

T = TypeVar("T")
D = TypeVar("D")

class StashKey(Generic[T]):
    """``StashKey`` is an object used as a key to a :class:`Stash`.

A ``StashKey`` is associated with the type ``T`` of the value of the key.

A ``StashKey`` is unique and cannot conflict with another key.
    """

__slots__ = ()

class Stash:
    r"""``Stash`` is a type-safe heterogeneous mutable mapping that
    allows keys and value types to be defined separately from
    where it (the ``Stash``) is created.

Usually you will be given an object which has a ``Stash``, for example
    :class:`~pytest.Config` or a :class:`~_pytest.nodes.Node`:

.. code-block:: python

stash: Stash = some_object.stash

If a module or plugin wants to store data in this ``Stash``, it creates
    :class:`StashKey`\s for its keys (at the module level):

.. code-block:: python

# At the top-level of the module
        some_str_key = StashKey[str]()
        some_bool_key = StashKey[bool]()

To store information:

.. code-block:: python

# Value type must match the key.
        stash[some_str_key] = "value"
        stash[some_bool_key] = True

To retrieve the information:

.. code-block:: python

# The static type of some_str is str.
        some_str = stash[some_str_key]
        # The static type of some_bool is bool.
        some_bool = stash[some_bool_key]
    """

__slots__ = ("_storage",)

def __init__(self) -> None:
        self._storage: Dict[StashKey[Any], object] = {}

def __setitem__(self, key: StashKey[T], value: T) -> None:
        """Set a value for key."""
        self._storage[key] = value

def __getitem__(self, key: StashKey[T]) -> T:
        """Get the value for key.

Raises ``KeyError`` if the key wasn't set before.
        """
        return cast(T, self._storage[key])

def get(self, key: StashKey[T], default: D) -> Union[T, D]:
        """Get the value for key, or return default if the key wasn't set
        before."""
        try:
            return self[key]
        except KeyError:
            return default

def setdefault(self, key: StashKey[T], default: T) -> T:
        """Return the value of key if already set, otherwise set the value
        of key to default and return default."""
        try:
            return self[key]
        except KeyError:
            self[key] = default
            return default

def __delitem__(self, key: StashKey[T]) -> None:
        """Delete the value for key.

Raises ``KeyError`` if the key wasn't set before.
        """
        del self._storage[key]

def __contains__(self, key: StashKey[T]) -> bool:
        """Return whether key was set."""
        return key in self._storage

def __len__(self) -> int:
        """Return how many items exist in the stash."""
        return len(self._storage)

X7ROOT File Manager

Editing: stash.py

Upload File

Create Folder