Coverage for requests.packages.urllib3._collections : 55%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
except ImportError: # Platform-specific: No threads available class RLock: def __enter__(self): pass
def __exit__(self, exc_type, exc_value, traceback): pass
except ImportError: from .packages.ordered_dict import OrderedDict
""" 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. self._container[key] = item return item
# 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)
return _dict_setitem(self, key.lower(), (key, val))
return _dict_delitem(self, key.lower())
return _dict_contains(self, key.lower())
if not isinstance(other, Mapping) and not hasattr(other, 'keys'): return False if not isinstance(other, type(self)): other = type(self)(other) return dict((k1, self[k1]) for k1 in self) == dict((k2, other[k2]) for k2 in other)
return not self.__eq__(other)
'''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 # new_vals was not inserted, as there was a previous one # If already several items got inserted, we have a list vals.append(val) else: # vals should be a tuple then, i.e. only one item so far # Need to convert the tuple to list for further extension
"""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 ({} 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 = _dict_getitem(self, key.lower()) except KeyError: return [] else: if isinstance(vals, tuple): return [vals[1]] else: return vals[1:]
# Backwards compatibility for httplib
return "%s(%s)" % (type(self).__name__, dict(self.itermerged()))
for key in other: val = _dict_getitem(other, key) if isinstance(val, list): # Don't need to convert tuples val = list(val) _dict_setitem(self, key, val)
clone = type(self)() clone._copy_from(self) return clone
"""Iterate over all header lines, including duplicate ones.""" for key in self: vals = _dict_getitem(self, key) for val in vals[1:]: yield vals[0], val
"""Iterate over all headers, merging duplicate ones together.""" for key in self: val = _dict_getitem(self, key) 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.
key, value = headers[-1] headers[-1] = (key, value + '\r\n' + line.rstrip()) continue
|