File Manager

X7ROOT File Manager

Current Path: /opt/hc_python/lib/python3.12/site-packages/requests

opt / hc_python / lib / python3.12 / site-packages / requests /

?? ..
?? __init__.py(5.78 KB)
?? __pycache__
?? __version__.py(435 B)
?? _internal_utils.py(1.51 KB)
?? _types.py(5.7 KB)
?? adapters.py(27.41 KB)
?? api.py(6.98 KB)
?? auth.py(11.95 KB)
?? certs.py(430 B)
?? compat.py(2.41 KB)
?? cookies.py(21.04 KB)
?? exceptions.py(4.46 KB)
?? help.py(4.11 KB)
?? hooks.py(1.11 KB)
?? models.py(40.8 KB)
?? packages.py(904 B)
?? py.typed(0 B)
?? sessions.py(33.45 KB)
?? status_codes.py(4.25 KB)
?? structures.py(4.04 KB)
?? utils.py(35.47 KB)

Editing: structures.py

"""
requests.structures
~~~~~~~~~~~~~~~~~~~

Data structures that power Requests.
"""

from __future__ import annotations

from collections import OrderedDict
from collections.abc import Iterable, Iterator, Mapping
from typing import Any, Generic, TypeVar, overload

from .compat import MutableMapping

_VT = TypeVar("_VT")
_D = TypeVar("_D")

class CaseInsensitiveDict(MutableMapping[str, _VT], Generic[_VT]):
    """A case-insensitive ``dict``-like object.

Implements all methods and operations of
    ``MutableMapping`` as well as dict's ``copy``. Also
    provides ``lower_items``.

All keys are expected to be strings. The structure remembers the
    case of the last key to be set, and ``iter(instance)``,
    ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
    will contain case-sensitive keys. However, querying and contains
    testing is case insensitive::

cid = CaseInsensitiveDict()
        cid['Accept'] = 'application/json'
        cid['aCCEPT'] == 'application/json'  # True
        list(cid) == ['Accept']  # True

For example, ``headers['content-encoding']`` will return the
    value of a ``'Content-Encoding'`` response header, regardless
    of how the header name was originally stored.

If the constructor, ``.update``, or equality comparison
    operations are given keys that have equal ``.lower()``s, the
    behavior is undefined.
    """

_store: OrderedDict[str, tuple[str, _VT]]

def __init__(
        self,
        data: Mapping[str, _VT] | Iterable[tuple[str, _VT]] | None = None,
        **kwargs: _VT,
    ) -> None:
        self._store = OrderedDict()
        if data is None:
            data = {}
        self.update(data, **kwargs)

def __setitem__(self, key: str, value: _VT) -> None:
        # Use the lowercased key for lookups, but store the actual
        # key alongside the value.
        self._store[key.lower()] = (key, value)

def __getitem__(self, key: str) -> _VT:
        return self._store[key.lower()][1]

def __delitem__(self, key: str) -> None:
        del self._store[key.lower()]

def __iter__(self) -> Iterator[str]:
        return (casedkey for casedkey, _ in self._store.values())

def __len__(self) -> int:
        return len(self._store)

def lower_items(self) -> Iterator[tuple[str, _VT]]:
        """Like iteritems(), but with all lowercase keys."""
        return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())

def __eq__(self, other: object) -> bool:
        if isinstance(other, Mapping):
            other_dict: CaseInsensitiveDict[Any] = CaseInsensitiveDict(other)  # type: ignore[reportUnknownArgumentType]
        else:
            return NotImplemented
        # Compare insensitively
        return dict(self.lower_items()) == dict(other_dict.lower_items())

# Copy is required
    def copy(self) -> CaseInsensitiveDict[_VT]:
        return CaseInsensitiveDict(self._store.values())

def __repr__(self) -> str:
        return str(dict(self.items()))

class LookupDict(dict[str, _VT]):
    """Dictionary lookup object."""

name: Any

def __init__(self, name: Any = None) -> None:
        self.name = name
        super().__init__()

def __repr__(self) -> str:
        return f"<lookup '{self.name}'>"

def __getattr__(self, key: str) -> _VT | None:
        # We need this for type checkers to infer typing
        # on attribute access with status_codes.py
        if key in self.__dict__:
            return self.__dict__[key]
        else:
            raise AttributeError(
                f"'{type(self).__name__}' object has no attribute '{key}'"
            )

def __getitem__(self, key: str) -> _VT | None:  # type: ignore[override]
        # We allow fall-through here, so values default to None

return self.__dict__.get(key, None)

@overload
    def get(self, key: str, default: None = None) -> _VT | None: ...

@overload
    def get(self, key: str, default: _D | _VT) -> _D | _VT: ...

def get(self, key: str, default: _D | None = None) -> _VT | _D | None:
        return self.__dict__.get(key, default)

X7ROOT File Manager

Editing: structures.py

Upload File

Create Folder