FM / requests

/usr/lib/imh-scan/venv/lib/python3.13/site-packages/requests/

/usr/lib/imh-scan/venv/lib/python3.13/site-packages/requests

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
adapters.py	26285	0644	edit dl rm
api.py	6449	0644	edit dl rm
auth.py	10186	0644	edit dl rm
certs.py	429	0644	edit dl rm
compat.py	2142	0644	edit dl rm
cookies.py	18590	0644	edit dl rm
exceptions.py	4260	0644	edit dl rm
help.py	3875	0644	edit dl rm
hooks.py	733	0644	edit dl rm
models.py	35510	0644	edit dl rm
packages.py	904	0644	edit dl rm
sessions.py	30503	0644	edit dl rm
status_codes.py	4322	0644	edit dl rm
structures.py	2912	0644	edit dl rm
utils.py	33213	0644	edit dl rm
_internal_utils.py	1495	0644	edit dl rm
__init__.py	5072	0644	edit dl rm
__version__.py	435	0644	edit dl rm

Edit: /usr/lib/imh-scan/venv/lib/python3.13/site-packages/requests/structures.py (2912B)

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

Data structures that power Requests.
"""

from collections import OrderedDict

from .compat import Mapping, MutableMapping

class CaseInsensitiveDict(MutableMapping):
    """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.
    """

def __init__(self, data=None, **kwargs):
        self._store = OrderedDict()
        if data is None:
            data = {}
        self.update(data, **kwargs)

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

def __getitem__(self, key):
        return self._store[key.lower()][1]

def __delitem__(self, key):
        del self._store[key.lower()]

def __iter__(self):
        return (casedkey for casedkey, mappedvalue in self._store.values())

def __len__(self):
        return len(self._store)

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

def __eq__(self, other):
        if isinstance(other, Mapping):
            other = CaseInsensitiveDict(other)
        else:
            return NotImplemented
        # Compare insensitively
        return dict(self.lower_items()) == dict(other.lower_items())

# Copy is required
    def copy(self):
        return CaseInsensitiveDict(self._store.values())

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

class LookupDict(dict):
    """Dictionary lookup object."""

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

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

def __getitem__(self, key):
        # We allow fall-through here, so values default to None

return self.__dict__.get(key, None)

def get(self, key, default=None):
        return self.__dict__.get(key, default)

cmd: