Coverage for /usr/local/lib/python3.7/dist-packages/requests/structures.py : 75%

# -*- coding: utf-8 -*- 

""" 

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(LookupDict, self).__init__() 

def __repr__(self): 

return '<lookup \'%s\'>' % (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)