|
except ImportError: from collections import Mapping, MutableMapping except ImportError: # Platform-specific: No threads available
class RLock: def __enter__(self): pass
def __exit__(self, exc_type, exc_value, traceback): pass
""" 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 """
# Re-insert the item, moving it to the end of the eviction line.
# Possibly evict the existing value of 'key'
# If we didn't evict an existing value, we might have to evict the # least recently used item from the beginning of the container. _key, evicted_value = self._container.popitem(last=False)
self.dispose_func(evicted_value)
with self.lock: value = self._container.pop(key)
if self.dispose_func: self.dispose_func(value)
with self.lock: return len(self._container)
raise NotImplementedError( "Iteration over this class is unlikely to be threadsafe." )
# Copy pointers to all values, then wipe the mapping
with self.lock: return list(iterkeys(self._container))
""" :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' """
self._copy_from(headers) else: self.extend(kwargs)
self._container[key.lower()] = [key, val] return self._container[key.lower()]
del self._container[key.lower()]
return key.lower() in self._container
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() )
return not self.__eq__(other)
iterkeys = MutableMapping.iterkeys itervalues = MutableMapping.itervalues
return len(self._container)
# Only provide the originally cased names
"""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
try: del self[key] except KeyError: pass
"""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' """ # Keep the common case aka no item present as fast as possible vals.append(val)
"""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__ """ raise TypeError( "extend() takes at most 1 positional " "arguments ({0} given)".format(len(args)) )
for key, val in other.iteritems(): self.add(key, val) for key in other: self.add(key, other[key]) for key in other.keys(): self.add(key, other[key]) else:
self.add(key, value)
"""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
# Backwards compatibility for http.cookiejar
def __repr__(self): return "%s(%s)" % (type(self).__name__, dict(self.itermerged()))
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
clone = type(self)() clone._copy_from(self) return clone
"""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
"""Iterate over all headers, merging duplicate ones together.""" for key in self: val = self._container[key.lower()] yield val[0], ", ".join(val[1:])
return list(self.iteritems())
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) |