Requests 源码阅读-Day2#

1
from .compat import Mapping, MutableMapping

1
import chardet
2

3
import sys
4

5
# -------
6
# Pythons
7
# -------
8

9
# Syntax sugar.
10
_ver = sys.version_info
11

12
#: Python 2.x?
13
is_py2 = (_ver[0] == 2)
14

15
#: Python 3.x?
16
is_py3 = (_ver[0] == 3)
17
...

1
elif is_py3:
2
    from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
3
    from urllib.request import parse_http_list, getproxies, proxy_bypass, proxy_bypass_environment, getproxies_environment
4
    from http import cookiejar as cookielib
5
    from http.cookies import Morsel
6
    from io import StringIO
7
    # Keep OrderedDict for backwards compatibility.
8
    from collections import OrderedDict
9
    from collections.abc import Callable, Mapping, MutableMapping
10

11
    builtin_str = str
12
    str = str
13
    bytes = bytes
14
    basestring = (str, bytes)
15
    numeric_types = (int, float)
16
    integer_types = (int,)

1
from _collections_abc import *
2
from _collections_abc import __all__

1
class MutableMapping(Mapping):
2

3
    __slots__ = ()
4
    """A MutableMapping is a generic container for associating
5
    key/value pairs.
6

7
    This class provides concrete generic implementations of all
8
    methods except for __getitem__, __setitem__, __delitem__,
9
    __iter__, and __len__.
10

11
    """
12

13
    @abstractmethod
14
    def __setitem__(self, key, value):
15
        raise KeyError
16

17
    @abstractmethod
18
    def __delitem__(self, key):
19
        raise KeyError
20

21
    __marker = object()
22

23
    def pop(self, key, default=__marker):
24
        '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
25
          If key is not found, d is returned if given, otherwise KeyError is raised.
26
        '''
27
        try:
28
            value = self[key]
29
        except KeyError:
30
            if default is self.__marker:
31
                raise
32
            return default
33
        else:
34
            del self[key]
35
            return value
36

37
    def popitem(self):
38
        '''D.popitem() -> (k, v), remove and return some (key, value) pair
39
           as a 2-tuple; but raise KeyError if D is empty.
40
        '''
41
        try:
42
            key = next(iter(self))
43
        except StopIteration:
44
            raise KeyError
45
        value = self[key]
46
        del self[key]
47
        return key, value
48

49
    def clear(self):
50
        'D.clear() -> None.  Remove all items from D.'
51
        try:
52
            while True:
53
                self.popitem()
54
        except KeyError:
55
            pass
56

57
    def update(*args, **kwds):
58
        ''' D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
59
            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
60
            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
61
            In either case, this is followed by: for k, v in F.items(): D[k] = v
62
        '''
63
        if not args:
64
            raise TypeError("descriptor 'update' of 'MutableMapping' object "
65
                            "needs an argument")
66
        self, *args = args
67
        if len(args) > 1:
68
            raise TypeError('update expected at most 1 arguments, got %d' %
69
                            len(args))
70
        if args:
71
            other = args[0]
72
            if isinstance(other, Mapping):
73
                for key in other:
74
                    self[key] = other[key]
75
            elif hasattr(other, "keys"):
76
                for key in other.keys():
77
                    self[key] = other[key]
78
            else:
79
                for key, value in other:
80
                    self[key] = value
81
        for key, value in kwds.items():
82
            self[key] = value
83

84
    def setdefault(self, key, default=None):
85
        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'
86
        try:
87
            return self[key]
88
        except KeyError:
89
            self[key] = default
90
        return default
91

92

93
MutableMapping.register(dict)

1
MutableMapping.register(dict)

1
from abc import ABC
2

3
class MyABC(ABC):
4
    pass
5

6
MyABC.register(tuple)
7

8
assert issubclass(tuple, MyABC)
9
assert isinstance((), MyABC)

1
from collections import OrderedDict

1
class OrderedDict(dict):
2
    'Dictionary that remembers insertion order'
3
    # An inherited dict maps keys to values.
4
    # The inherited dict provides __getitem__, __len__, __contains__, and get.
5
    # The remaining methods are order-aware.
6
    # Big-O running times for all methods are the same as regular dictionaries
7

8
    ....

1
from .compat import Mapping, MutableMapping
2

3

4
class CaseInsensitiveDict(MutableMapping):
5
....
6
def update(*args, **kwds):
7
        ''' D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
8
            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
9
            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
10
            In either case, this is followed by: for k, v in F.items(): D[k] = v
11
        '''
12
        if not args:
13
            raise TypeError("descriptor 'update' of 'MutableMapping' object "
14
                            "needs an argument")
15
        self, *args = args
16
        if len(args) > 1:
17
            raise TypeError('update expected at most 1 arguments, got %d' %
18
                            len(args))
19
        if args:
20
            other = args[0]
21
            if isinstance(other, Mapping):
22
                for key in other:
23
                    self[key] = other[key]
24
            elif hasattr(other, "keys"):
25
                for key in other.keys():
26
                    self[key] = other[key]
27
            else:
28
                for key, value in other:
29
                    self[key] = value
30

31
        for key, value in kwds.items():
32
            self[key] = value