拆輪子：requests

樑健發表於2018-07-19

前言

看書獲心法，看大牛寫的專案獲形法。當我搜尋，python原始碼閱讀推薦，看到基本都有requests這個包，本身也經常用這個包，關鍵是這個包相對來說比較簡單，就愉快的決定從這個輪子開始拆了。大體看完後，(〃´皿`)q膜拜Kenneth Reitz，狂打call，人帥，程式碼寫得更帥，還是減肥勵志級別人物。

感覺有趣，值得學習，借鑑的

目錄結構

原先的目錄檔案結構並沒有這樣劃分得這麼清晰，只有一個core.py檔案，裡面包含了一切。這樣劃分的好處就是，相同功能的劃分到一個檔案裡頭，更加的清晰。這裡提供了很好的檔案命名規範，具體的如下注釋。哈哈哈，以後自己寫程式碼，目錄結構按照這裡的來，完美。

├── requests
│   ├── __init__.py
│   ├── adapters.py
│   ├── api.py              # 提供對外的api呼叫 
│   ├── auth.py			
│   ├── cacert.pem
│   ├── certs.py
│   ├── compat.py			# python2和python3相容
│   ├── cookies.py
│   ├── exceptions.py		# 各種異常
│   ├── hooks.py		
│   ├── models.py			# 程式碼中會用到的自定義類
│   ├── packages  			# 存放第三方模組
│   │   ├── README.rst
│   │   ├── __init__.py
│   │   ├── chardet
│   │   └── urllib3
│   ├── sessions.py		
│   ├── status_codes.py		# 全域性各種狀態碼
│   ├── structures.py		# 自定義的容器類
│   └── utils.py			# 各種工具方法

複製程式碼

優雅的hook函式

平時自己寫函式，有時也會提供回撥處理之類的，但是一般屬於寫死型，不夠通用。在v0.6.0版本中看到，以下用法時，Σ（ﾟдﾟlll）目瞪口呆，臥槽，強，牛逼。核心思路是1. 若有hook函式就處理，沒有就返回原有資料，2. 利用**kwargs可以傳入各種不同的引數（不用args估計是因為讓引數意義更明確）。寫一個通用 利用上partial，改造一下，就能變化出各種不同場景的hook處理了。

# v2.9.2 版本的，比起最初版，增加了點判斷，思路是一樣的。

HOOKS = ['response']	# 限定dispatch_hook所能處理的hook函式

def default_hooks():
    return dict((event, []) for event in HOOKS)

# TODO: response is the only one

# 這函式，若有hook函式就處理，沒有就返回原有資料。這個沒有就返回原來的資料很重要！！！呼叫時就可以不用判斷，直接寫寫就行了。
def dispatch_hook(key, hooks, hook_data, **kwargs):
    """Dispatches a hook dictionary on a given piece of data."""
    hooks = hooks or dict()
    hooks = hooks.get(key)
    if hooks:
        if hasattr(hooks, '__call__'):  
            hooks = [hooks]
        for hook in hooks:
            _hook_data = hook(hook_data, **kwargs)
            if _hook_data is not None:
                hook_data = _hook_data
    return hook_data



# v0.6.0用法, 最初版的更能體會到dispatch_hook的強大。
args = dispatch_hook('args', hooks, args)

r = Request(**args)

# Pre-request hook.
r = dispatch_hook('pre_request', hooks, r)

# Send the HTTP Request.
r.send()

# Post-request hook.
r = dispatch_hook('post_request', hooks, r)

複製程式碼

對於狀態碼是數字，但又想程式碼意義明確的優雅處理

以前寫程式碼經常會這種反人類的寫法if status == 1: do something。之後將它改進遊戲，在檔案開頭用大寫的變數定義狀態，然後引入。但是看到下面的用法時，我看到了更加優雅的解決辦法。核心思路：1. 將各種狀態碼寫入一個檔案 2. 用屬性名來代替數字狀態碼


_codes = {

    # Informational.
    100: ('continue',),
    101: ('switching_protocols',),
    102: ('processing',),
    103: ('checkpoint',),
    122: ('uri_too_long', 'request_uri_too_long'),
    200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/', '✓'),  # 支援多種對映66666
    201: ('created',),
    202: ('accepted',),
    203: ('non_authoritative_info', 'non_authoritative_information'),
    204: ('no_content',),
    205: ('reset_content', 'reset'),
    206: ('partial_content', 'partial'),
    207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
    208: ('already_reported',),
    226: ('im_used',),
	
	# 後面還有n多，果斷省略

}

# 自定義的dict類似的容器類
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)
	
	# python語言框架呼叫的，實現了這個就可以obj["item"]這樣呼叫。典型的面向介面程式設計哲學思想
    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)


codes = LookupDict(name='status_codes')

for code, titles in _codes.items():
    for title in titles:
        setattr(codes, title, code)
        if not title.startswith('\\'):
            setattr(codes, title.upper(), code)
            
# 然後就可以這樣用了
 if response.status_code == codes.see_other and method != 'HEAD'
 	pass
 	
 if response.status_code == codes['see_other'] and method != 'HEAD'
	pass
            
複製程式碼

一個相容python2與python3的思路

一個名為compat.py的檔案吸引了我的眼球，相容總給我一種這是高大上的用法的感覺。裡面給出了一個相容2和3的思路。python2與3大體上的不同點1. 部分包名路徑設定名字變了 2. 字串，整形等基礎資料型別的改變。而compat.py的核心思路是：將不同的弄成一樣，然後其他檔案，從該檔案import。


if is_py2:
    from urllib import quote, unquote, quote_plus, unquote_plus, urlencode, getproxies, proxy_bypass
    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urldefrag
    from urllib2 import parse_http_list
    import cookielib
    from Cookie import Morsel
    from StringIO import StringIO
    from .packages.urllib3.packages.ordered_dict import OrderedDict

    builtin_str = str
    bytes = str
    str = unicode
    basestring = basestring
    numeric_types = (int, long, float)

elif is_py3:
    from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
    from urllib.request import parse_http_list, getproxies, proxy_bypass
    from http import cookiejar as cookielib
    from http.cookies import Morsel
    from io import StringIO
    from collections import OrderedDict

    builtin_str = str
    str = str
    bytes = bytes
    basestring = (str, bytes)
    numeric_types = (int, float)

複製程式碼

利用類來做上下文管理

上下文管理又是一個高階用法。最初的session的管理是用裝飾器來做的，每個字母我都認識，但我完全看不懂！！！！但大神就大神，後來改用類來做，程式碼優雅度，可讀性上升N個臺階。核心思路：建立一個專門用來管理上下文的類，利用物件屬性，在下次操作時，將需要繼續使用的，傳入函式中。描述得比較魔幻，需要配合程式碼來理解。


class Session(SessionRedirectMixin)
	def __init__():
		# 註釋全部去掉了，
		self.headers = default_headers()
        self.auth = None
        self.proxies = {}
        self.hooks = default_hooks()
        self.params = {}
        self.stream = False
        self.verify = True
        self.cert = None
        self.max_redirects = DEFAULT_REDIRECT_LIMIT
        self.trust_env = True
        self.cookies = cookiejar_from_dict({})	# 主要觀察點cookies, 下次請求帶上上次的
        self.adapters = OrderedDict()
        self.mount('https://', HTTPAdapter())
        self.mount('http://', HTTPAdapter())
        self.redirect_cache = RecentlyUsedContainer(REDIRECT_CACHE_SIZE)
	
	def prepare_request(self, request):
	  ..... 持續省略
      cookies = request.cookies or {}

      # Bootstrap CookieJar.
      if not isinstance(cookies, cookielib.CookieJar):
          cookies = cookiejar_from_dict(cookies)

      # 上次請求的cookies會被儲存到self.cookies這個屬性裡面，然後下次請求時帶上。
      merged_cookies = merge_cookies(
          merge_cookies(RequestsCookieJar(), self.cookies), cookies)

	
      # Set environment's basic authentication if not explicitly set.
      ..... 持續省略
      return p	
	
	
	# 實現了這兩個方法，就可以with Session() as session：dosomething
	def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

複製程式碼

教科書式的類繼承體系

講真，看同事寫的程式碼，自己寫的程式碼，在類繼體系這一塊，普遍都做得不好，為了方便，經常是亂繼承，導致程式碼過度耦合！！！在殿堂級神書《冒號課堂》，有兩句話，值得背下下來。1. 提倡介面繼承，慎用實現繼承。2. 非抽象類不適合作基類。補充一下，mixin類就是帶實現的介面，不應該被例項化使用，算是介面繼承。

auth.py

# 專門設計出來，用於抽象的基類
class AuthBase(object):
    """Base class that all auth implementations derive from"""

    def __call__(self, r):
        raise NotImplementedError('Auth hooks must be callable.')
        
        
class HTTPBasicAuth(AuthBase):
	....省略

    def __call__(self, r):
        r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
        return r


class HTTPProxyAuth(HTTPBasicAuth):
    def __call__(self, r):
        r.headers['Proxy-Authorization'] = _basic_auth_str(self.username, self.password)
        return r


class HTTPDigestAuth(AuthBase):
	....繼續省略
	
    def __call__(self, r):
        # Initialize per-thread state, if needed
        self.init_per_thread_state()
        # If we have a saved nonce, skip the 401
        if self._thread_local.last_nonce:
            r.headers['Authorization'] = self.build_digest_header(r.method, r.url)
        try:
            self._thread_local.pos = r.body.tell()
        except AttributeError:
            # In the case of HTTPDigestAuth being reused and the body of
            # the previous request was a file-like object, pos has the
            # file position of the previous body. Ensure it's set to
            # None.
            self._thread_local.pos = None
        r.register_hook('response', self.handle_401)
        r.register_hook('response', self.handle_redirect)
        self._thread_local.num_401_calls = 1


models.py
# 將一些子類會公用到的，做成mixin類。多重繼承也非魔鬼啊。另外的，標準庫也有很多mixin類，有興趣，可以再去看看collections模組裡面的用法

class RequestEncodingMixin(object)
    pass

class RequestHooksMixin(object):
    pass
  
class PreparedRequest(RequestEncodingMixin, RequestHooksMixin)
    pass

class Request(RequestHooksMixin)
    pass
    
複製程式碼

一個設定引數預設值的思路

在方法裡面設定，而非在引數裡面設定。適合引數巨多的場景

def send(self, request, **kwargs):
  # 
  kwargs.setdefault('stream', self.stream)
  kwargs.setdefault('verify', self.verify)
  kwargs.setdefault('cert', self.cert)
  kwargs.setdefault('proxies', self.proxies)
複製程式碼

更快速自定義容器類

在models.py中看到了一個class CaseInsensitiveDict(collections.MutableMapping): pass 這樣的用法。一般嘛，自定義容器類，需要實現各種各樣的magic方法，對外介面啊。做為一個懶人，每次自定義都有實現實在是麻煩，還可能會漏。官方提供collections模組來拯救世界，裡面有很多已經定義好的抽象基類。只要實現了要求的magic方法（沒有實現還會很貼心的報錯，告訴你沒有實現），那麼可以使用相對於的介面。

最後的嘮叨

看原始碼的思路，主要是看用法，具體的和網路相關詳細而且細節的知識略過。目的不是為了學習網路相關的細節知識，所以略過，就算要學也不應該看程式碼來學，太零散沒有價值，應該要去看相關的協議。

相關文章