| from __future__ import absolute_import |
| |
| try: |
| from collections.abc import Mapping, MutableMapping |
| except ImportError: |
| from collections import Mapping, MutableMapping |
| try: |
| from threading import RLock |
| except ImportError: # Platform-specific: No threads available |
| |
| class RLock: |
| def __enter__(self): |
| pass |
| |
| def __exit__(self, exc_type, exc_value, traceback): |
| pass |
| |
| |
| from collections import OrderedDict |
| |
| from .exceptions import InvalidHeader |
| from .packages import six |
| from .packages.six import iterkeys, itervalues |
| |
| __all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"] |
| |
| |
| _Null = object() |
| |
| |
| class RecentlyUsedContainer(MutableMapping): |
| """ |
| Provides a thread-safe dict-like container which maintains up to |
| ``maxsize`` keys while throwing away the least-recently-used keys beyond |
| ``maxsize``. |
| |
| :param maxsize: |
| Maximum number of recent elements to retain. |
| |
| :param dispose_func: |
| Every time an item is evicted from the container, |
| ``dispose_func(value)`` is called. Callback which will get called |
| """ |
| |
| ContainerCls = OrderedDict |
| |
| def __init__(self, maxsize=10, dispose_func=None): |
| self._maxsize = maxsize |
| self.dispose_func = dispose_func |
| |
| self._container = self.ContainerCls() |
| self.lock = RLock() |
| |
| def __getitem__(self, key): |
| # Re-insert the item, moving it to the end of the eviction line. |
| with self.lock: |
| item = self._container.pop(key) |
| self._container[key] = item |
| return item |
| |
| def __setitem__(self, key, value): |
| evicted_value = _Null |
| with self.lock: |
| # Possibly evict the existing value of 'key' |
| evicted_value = self._container.get(key, _Null) |
| self._container[key] = value |
| |
| # If we didn't evict an existing value, we might have to evict the |
| # least recently used item from the beginning of the container. |
| if len(self._container) > self._maxsize: |
| _key, evicted_value = self._container.popitem(last=False) |
| |
| if self.dispose_func and evicted_value is not _Null: |
| self.dispose_func(evicted_value) |
| |
| def __delitem__(self, key): |
| with self.lock: |
| value = self._container.pop(key) |
| |
| if self.dispose_func: |
| self.dispose_func(value) |
| |
| def __len__(self): |
| with self.lock: |
| return len(self._container) |
| |
| def __iter__(self): |
| raise NotImplementedError( |
| "Iteration over this class is unlikely to be threadsafe." |
| ) |
| |
| def clear(self): |
| with self.lock: |
| # Copy pointers to all values, then wipe the mapping |
| values = list(itervalues(self._container)) |
| self._container.clear() |
| |
| if self.dispose_func: |
| for value in values: |
| self.dispose_func(value) |
| |
| def keys(self): |
| with self.lock: |
| return list(iterkeys(self._container)) |
| |
| |
| class HTTPHeaderDict(MutableMapping): |
| """ |
| :param headers: |
| An iterable of field-value pairs. Must not contain multiple field names |
| when compared case-insensitively. |
| |
| :param kwargs: |
| Additional field-value pairs to pass in to ``dict.update``. |
| |
| A ``dict`` like container for storing HTTP Headers. |
| |
| Field names are stored and compared case-insensitively in compliance with |
| RFC 7230. Iteration provides the first case-sensitive key seen for each |
| case-insensitive pair. |
| |
| Using ``__setitem__`` syntax overwrites fields that compare equal |
| case-insensitively in order to maintain ``dict``'s api. For fields that |
| compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add`` |
| in a loop. |
| |
| If multiple fields that are equal case-insensitively are passed to the |
| constructor or ``.update``, the behavior is undefined and some will be |
| lost. |
| |
| >>> headers = HTTPHeaderDict() |
| >>> headers.add('Set-Cookie', 'foo=bar') |
| >>> headers.add('set-cookie', 'baz=quxx') |
| >>> headers['content-length'] = '7' |
| >>> headers['SET-cookie'] |
| 'foo=bar, baz=quxx' |
| >>> headers['Content-Length'] |
| '7' |
| """ |
| |
| def __init__(self, headers=None, **kwargs): |
| super(HTTPHeaderDict, self).__init__() |
| self._container = OrderedDict() |
| if headers is not None: |
| if isinstance(headers, HTTPHeaderDict): |
| self._copy_from(headers) |
| else: |
| self.extend(headers) |
| if kwargs: |
| self.extend(kwargs) |
| |
| def __setitem__(self, key, val): |
| self._container[key.lower()] = [key, val] |
| return self._container[key.lower()] |
| |
| def __getitem__(self, key): |
| val = self._container[key.lower()] |
| return ", ".join(val[1:]) |
| |
| def __delitem__(self, key): |
| del self._container[key.lower()] |
| |
| def __contains__(self, key): |
| return key.lower() in self._container |
| |
| def __eq__(self, other): |
| if not isinstance(other, Mapping) and not hasattr(other, "keys"): |
| return False |
| if not isinstance(other, type(self)): |
| other = type(self)(other) |
| return dict((k.lower(), v) for k, v in self.itermerged()) == dict( |
| (k.lower(), v) for k, v in other.itermerged() |
| ) |
| |
| def __ne__(self, other): |
| return not self.__eq__(other) |
| |
| if six.PY2: # Python 2 |
| iterkeys = MutableMapping.iterkeys |
| itervalues = MutableMapping.itervalues |
| |
| __marker = object() |
| |
| def __len__(self): |
| return len(self._container) |
| |
| def __iter__(self): |
| # Only provide the originally cased names |
| for vals in self._container.values(): |
| yield vals[0] |
| |
| def pop(self, key, default=__marker): |
| """D.pop(k[,d]) -> v, remove specified key and return the corresponding value. |
| If key is not found, d is returned if given, otherwise KeyError is raised. |
| """ |
| # Using the MutableMapping function directly fails due to the private marker. |
| # Using ordinary dict.pop would expose the internal structures. |
| # So let's reinvent the wheel. |
| try: |
| value = self[key] |
| except KeyError: |
| if default is self.__marker: |
| raise |
| return default |
| else: |
| del self[key] |
| return value |
| |
| def discard(self, key): |
| try: |
| del self[key] |
| except KeyError: |
| pass |
| |
| def add(self, key, val): |
| """Adds a (name, value) pair, doesn't overwrite the value if it already |
| exists. |
| |
| >>> headers = HTTPHeaderDict(foo='bar') |
| >>> headers.add('Foo', 'baz') |
| >>> headers['foo'] |
| 'bar, baz' |
| """ |
| key_lower = key.lower() |
| new_vals = [key, val] |
| # Keep the common case aka no item present as fast as possible |
| vals = self._container.setdefault(key_lower, new_vals) |
| if new_vals is not vals: |
| vals.append(val) |
| |
| def extend(self, *args, **kwargs): |
| """Generic import function for any type of header-like object. |
| Adapted version of MutableMapping.update in order to insert items |
| with self.add instead of self.__setitem__ |
| """ |
| if len(args) > 1: |
| raise TypeError( |
| "extend() takes at most 1 positional " |
| "arguments ({0} given)".format(len(args)) |
| ) |
| other = args[0] if len(args) >= 1 else () |
| |
| if isinstance(other, HTTPHeaderDict): |
| for key, val in other.iteritems(): |
| self.add(key, val) |
| elif isinstance(other, Mapping): |
| for key in other: |
| self.add(key, other[key]) |
| elif hasattr(other, "keys"): |
| for key in other.keys(): |
| self.add(key, other[key]) |
| else: |
| for key, value in other: |
| self.add(key, value) |
| |
| for key, value in kwargs.items(): |
| self.add(key, value) |
| |
| def getlist(self, key, default=__marker): |
| """Returns a list of all the values for the named field. Returns an |
| empty list if the key doesn't exist.""" |
| try: |
| vals = self._container[key.lower()] |
| except KeyError: |
| if default is self.__marker: |
| return [] |
| return default |
| else: |
| return vals[1:] |
| |
| # Backwards compatibility for httplib |
| getheaders = getlist |
| getallmatchingheaders = getlist |
| iget = getlist |
| |
| # Backwards compatibility for http.cookiejar |
| get_all = getlist |
| |
| def __repr__(self): |
| return "%s(%s)" % (type(self).__name__, dict(self.itermerged())) |
| |
| def _copy_from(self, other): |
| for key in other: |
| val = other.getlist(key) |
| if isinstance(val, list): |
| # Don't need to convert tuples |
| val = list(val) |
| self._container[key.lower()] = [key] + val |
| |
| def copy(self): |
| clone = type(self)() |
| clone._copy_from(self) |
| return clone |
| |
| def iteritems(self): |
| """Iterate over all header lines, including duplicate ones.""" |
| for key in self: |
| vals = self._container[key.lower()] |
| for val in vals[1:]: |
| yield vals[0], val |
| |
| def itermerged(self): |
| """Iterate over all headers, merging duplicate ones together.""" |
| for key in self: |
| val = self._container[key.lower()] |
| yield val[0], ", ".join(val[1:]) |
| |
| def items(self): |
| return list(self.iteritems()) |
| |
| @classmethod |
| def from_httplib(cls, message): # Python 2 |
| """Read headers from a Python 2 httplib message object.""" |
| # python2.7 does not expose a proper API for exporting multiheaders |
| # efficiently. This function re-reads raw lines from the message |
| # object and extracts the multiheaders properly. |
| obs_fold_continued_leaders = (" ", "\t") |
| headers = [] |
| |
| for line in message.headers: |
| if line.startswith(obs_fold_continued_leaders): |
| if not headers: |
| # We received a header line that starts with OWS as described |
| # in RFC-7230 S3.2.4. This indicates a multiline header, but |
| # there exists no previous header to which we can attach it. |
| raise InvalidHeader( |
| "Header continuation with no previous header: %s" % line |
| ) |
| else: |
| key, value = headers[-1] |
| headers[-1] = (key, value + " " + line.strip()) |
| continue |
| |
| key, value = line.split(":", 1) |
| headers.append((key, value.strip())) |
| |
| return cls(headers) |
