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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

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

 

""" 

requests.structures 

~~~~~~~~~~~~~~~~~~~ 

 

Data structures that power Requests. 

 

""" 

 

import os 

import collections 

from itertools import islice 

 

 

class IteratorProxy(object): 

    """docstring for IteratorProxy""" 

    def __init__(self, i): 

        self.i = i 

        # self.i = chain.from_iterable(i) 

 

    def __iter__(self): 

        return self.i 

 

    def __len__(self): 

        if hasattr(self.i, '__len__'): 

            return len(self.i) 

        if hasattr(self.i, 'len'): 

            return self.i.len 

        if hasattr(self.i, 'fileno'): 

            return os.fstat(self.i.fileno()).st_size 

 

    def read(self, n): 

        return "".join(islice(self.i, None, n)) 

 

 

class CaseInsensitiveDict(collections.MutableMapping): 

    """ 

    A case-insensitive ``dict``-like object. 

 

    Implements all methods and operations of 

    ``collections.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 = dict() 

        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, collections.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)