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

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

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 

 

 

try:  # Python 2.7+ 

    from collections import OrderedDict 

except ImportError: 

    from .packages.ordered_dict import OrderedDict 

from .packages.six import iterkeys, itervalues, PY3 

 

 

__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)) 

 

 

_dict_setitem = dict.__setitem__ 

_dict_getitem = dict.__getitem__ 

_dict_delitem = dict.__delitem__ 

_dict_contains = dict.__contains__ 

_dict_setdefault = dict.setdefault 

 

 

class HTTPHeaderDict(dict): 

    """ 

    :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): 

        dict.__init__(self) 

        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): 

        return _dict_setitem(self, key.lower(), (key, val)) 

 

    def __getitem__(self, key): 

        val = _dict_getitem(self, key.lower()) 

        return ', '.join(val[1:]) 

 

    def __delitem__(self, key): 

        return _dict_delitem(self, key.lower()) 

 

    def __contains__(self, key): 

        return _dict_contains(self, key.lower()) 

 

    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((k1, self[k1]) for k1 in self) == dict((k2, other[k2]) for k2 in other) 

 

    def __ne__(self, other): 

        return not self.__eq__(other) 

 

    values = MutableMapping.values 

    get = MutableMapping.get 

    update = MutableMapping.update 

 

    if not PY3: # Python 2 

        iterkeys = MutableMapping.iterkeys 

        itervalues = MutableMapping.itervalues 

 

    __marker = object() 

 

    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 = _dict_setdefault(self, key_lower, new_vals) 

        if new_vals is not vals: 

            # new_vals was not inserted, as there was a previous one 

            if isinstance(vals, list): 

                # 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 

                _dict_setitem(self, key_lower, [vals[0], vals[1], 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 ({} 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): 

        """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 

    getheaders = getlist 

    getallmatchingheaders = getlist 

    iget = getlist 

 

    def __repr__(self): 

        return "%s(%s)" % (type(self).__name__, dict(self.itermerged())) 

 

    def _copy_from(self, other): 

        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) 

 

    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 = _dict_getitem(self, key) 

            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 = _dict_getitem(self, key) 

            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. 

        headers = [] 

 

        for line in message.headers: 

            if line.startswith((' ', '\t')): 

                key, value = headers[-1] 

                headers[-1] = (key, value + '\r\n' + line.rstrip()) 

                continue 

 

            key, value = line.split(':', 1) 

            headers.append((key, value.strip())) 

 

        return cls(headers)