#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Author:wd

import threading
import time
values=threading.local()

def run(arg):
  values.num=arg #修改threading.local對象的name數(shù)據(jù)
  time.sleep(1)
  print(threading.current_thread().name,values.num) #打印values.num


for i in range(3):
  th = threading.Thread(target=run, args=(i,), name='run thread%s' % i)
  th.start()

try:
  from greenlet import getcurrent as get_ident # 攜程唯一標(biāo)識
except ImportError:
  try:
    from thread import get_ident
  except ImportError:
    from _thread import get_ident # 線程唯一標(biāo)識


class Local(object):
  def __init__(self):
    object.__setattr__(self, 'storage', dict()) # 防止self.xxx 遞歸
    object.__setattr__(self, '__get_ident__', get_ident)

  def __setattr__(self, key, value):
    ident = self.__get_ident__() # 獲取當(dāng)前線程或協(xié)程的唯一標(biāo)識
    data = self.storage.get(ident)
    if not data: # 當(dāng)前線程沒有數(shù)據(jù)
      data = {key: value} # 創(chuàng)建數(shù)據(jù)
    else: # 當(dāng)前已經(jīng)有數(shù)據(jù)
      data[key] = value

    self.storage[ident] = data # 最后為當(dāng)前線程設(shè)置其標(biāo)識對應(yīng)的數(shù)據(jù)

  def __getattr__(self, name):
    try:
      return self.storage[self.__get_ident__()].get(name) # 返回name所對應(yīng)的值
    except KeyError:
      raise AttributeError(name)

from functools import partial

def func(x,y,z):
  print(x,y,z)

new_fun=partial(func,1,2) #生成新的函數(shù)，該函數(shù)中已經(jīng)有一個(gè)參數(shù)
new_fun(3)

from werkzeug.wrappers import Request, Response

@Request.application
def application(request):
  return Response('Hello World!')

if __name__ == '__main__':
  from werkzeug.serving import run_simple
  run_simple('localhost', 4000, application)

from flask import Flask

app=Flask(__name__)
@app.route("/")
def hello():
  return 'hello world'

if __name__=='__main__':
  app.run()

from werkzeug.serving import run_simple

try:
  run_simple(host, port, self, **options)
finally:
  # reset the first request information if the development server
  # reset normally. This makes it possible to restart the server
  # without reloader and that stuff from an interactive shell.
  self._got_first_request = False

def __call__(self, environ, start_response):
  """The WSGI server calls the Flask application object as the
  WSGI application. This calls :meth:`wsgi_app` which can be
  wrapped to applying middleware."""
  return self.wsgi_app(environ, start_response)

def wsgi_app(self, environ, start_response):
  """The actual WSGI application. This is not implemented in
  :meth:`__call__` so that middlewares can be applied without
  losing a reference to the app object. Instead of doing this::

    app = MyMiddleware(app)

  It's a better idea to do this instead::

    app.wsgi_app = MyMiddleware(app.wsgi_app)

  Then you still have the original application object around and
  can continue to call methods on it.

  .. versionchanged:: 0.7
    Teardown events for the request and app contexts are called
    even if an unhandled error occurs. Other events may not be
    called depending on when an error occurs during dispatch.
    See :ref:`callbacks-and-errors`.

  :param environ: A WSGI environment.
  :param start_response: A callable accepting a status code,
    a list of headers, and an optional exception context to
    start the response.
  """
  #ctx.app 當(dāng)前app名稱
  #ctx.request request對象，由app.request_class(environ)生成
  #ctx.session session 相關(guān)信息
  ctx = self.request_context(environ) 
  error = None
  try:
    try:
      ctx.push()
      #push數(shù)據(jù)到local，此時(shí)push的數(shù)據(jù)分請求上線文和應(yīng)用上下文
      # 將ctx通過Localstack添加到local中
      # app_ctx是APPContext對象
      response = self.full_dispatch_request()
    except Exception as e:
      error = e
      response = self.handle_exception(e)
    except:
      error = sys.exc_info()[1]
      raise
    return response(environ, start_response)
  finally:
    if self.should_ignore_error(error):
      error = None
    ctx.auto_pop(error)

def __init__(self, app, environ, request=None):
  self.app = app
  if request is None:
    request = app.request_class(environ)
  self.request = request
  self.url_adapter = app.create_url_adapter(self.request)
  self.flashes = None
  self.session = None

def push(self):
  """Binds the request context to the current context."""
  # If an exception occurs in debug mode or if context preservation is
  # activated under exception situations exactly one context stays
  # on the stack. The rationale is that you want to access that
  # information under debug situations. However if someone forgets to
  # pop that context again we want to make sure that on the next push
  # it's invalidated, otherwise we run at risk that something leaks
  # memory. This is usually only a problem in test suite since this
  # functionality is not active in production environments.
  top = _request_ctx_stack.top
  if top is not None and top.preserved:
    top.pop(top._preserved_exc)

  # Before we push the request context we have to ensure that there
  # is an application context.
  app_ctx = _app_ctx_stack.top #獲取應(yīng)用上線文，一開始為none
  if app_ctx is None or app_ctx.app != self.app:
    # 創(chuàng)建APPContext(self)對象，app_ctx=APPContext(self)
    # 包含app_ctx.app ,當(dāng)前app對象
    # 包含app_ctx.g , g可以看作是一個(gè)字典用來保存一個(gè)請求周期需要保存的值
    app_ctx = self.app.app_context()
    app_ctx.push()
    self._implicit_app_ctx_stack.append(app_ctx)
  else:
    self._implicit_app_ctx_stack.append(None)

  if hasattr(sys, 'exc_clear'):
    sys.exc_clear()
  #self 是RequestContext對象，其中包含了請求相關(guān)的所有數(shù)據(jù)
  _request_ctx_stack.push(self)

  # Open the session at the moment that the request context is available.
  # This allows a custom open_session method to use the request context.
  # Only open a new session if this is the first time the request was
  # pushed, otherwise stream_with_context loses the session.
  if self.session is None:
    session_interface = self.app.session_interface # 獲取session信息
    self.session = session_interface.open_session(
      self.app, self.request
    )

    if self.session is None:
      self.session = session_interface.make_null_session(self.app)

def __init__(self, app):
  self.app = app
  self.url_adapter = app.create_url_adapter(None)
  self.g = app.app_ctx_globals_class()

  # Like request context, app contexts can be pushed multiple times
  # but there a basic "refcount" is enough to track them.
  self._refcnt = 0

def push(self, obj):
  """Pushes a new item to the stack"""
  #找_local對象中是否有stack，沒有設(shè)置rv和_local.stack都為[]
  rv = getattr(self._local, 'stack', None)
  if rv is None:
    self._local.stack = rv = []
    # 執(zhí)行Local對象的__setattr__方法，等價(jià)于a=[],rv=a, self._local.stack =a
    #創(chuàng)建字典，類似于storage={'唯一標(biāo)識':{'stack':[]}}
  rv.append(obj)
    #列表中追加請求相關(guān)所有數(shù)據(jù)也就是storage={'唯一標(biāo)識':{'stack':[RequestContext對象,]}}
  return rv

class Local(object):
  __slots__ = ('__storage__', '__ident_func__')

  def __init__(self):
    object.__setattr__(self, '__storage__', {})
    object.__setattr__(self, '__ident_func__', get_ident)

  def __iter__(self):
    return iter(self.__storage__.items())

  def __call__(self, proxy):
    """Create a proxy for a name."""
    return LocalProxy(self, proxy)

  def __release_local__(self):
    self.__storage__.pop(self.__ident_func__(), None)

  def __getattr__(self, name):
    try:
      return self.__storage__[self.__ident_func__()][name]
    except KeyError:
      raise AttributeError(name)

  def __setattr__(self, name, value):
    ident = self.__ident_func__()
    storage = self.__storage__
    try:
      storage[ident][name] = value
    except KeyError:
      storage[ident] = {name: value}

  def __delattr__(self, name):
    try:
      del self.__storage__[self.__ident_func__()][name]
    except KeyError:
      raise AttributeError(name)

Local()

def full_dispatch_request(self):
  """Dispatches the request and on top of that performs request
  pre and postprocessing as well as HTTP exception catching and
  error handling.

  .. versionadded:: 0.7
  """
  self.try_trigger_before_first_request_functions()
  try:
    request_started.send(self)
    rv = self.preprocess_request()
    if rv is None:
      rv = self.dispatch_request()
  except Exception as e:
    rv = self.handle_user_exception(e)
  return self.finalize_request(rv)

request = LocalProxy(partial(_lookup_req_object, 'request'))

def __init__(self, local, name=None):
  #local是傳入的函數(shù)，該句等價(jià)于self.__local=local,_類名__字段強(qiáng)行設(shè)置私有字段值
  #如果是requst則函數(shù)就是partial(_lookup_req_object, 'request')
  object.__setattr__(self, '_LocalProxy__local', local)
  object.__setattr__(self, '__name__', name) #開始的時(shí)候設(shè)置__name__的值為None
  if callable(local) and not hasattr(local, '__release_local__'):
    # "local" is a callable that is not an instance of Local or
    # LocalManager: mark it as a wrapped function.
    object.__setattr__(self, '__wrapped__', local)

def __getattr__(self, name):
  #以獲取request.method 為例子，此時(shí)name=method
  if name == '__members__':
    return dir(self._get_current_object())
  #self._get_current_object()返回的是ctx.request,再從ctx.request獲取method (ctx.request.method)
  return getattr(self._get_current_object(), name)

def _lookup_req_object(name):
  #以name=request為列
  top = _request_ctx_stack.top
  # top是就是RequestContext(ctx)對象，里面含有request、session 等
  if top is None:
    raise RuntimeError(_request_ctx_err_msg)
  return getattr(top, name) #到RequestContext（ctx）中獲取那么為request的值

# context locals
_request_ctx_stack = LocalStack() #LocalStack()包含pop、push方法以及Local對象，上下文通過該對象push和pop
_app_ctx_stack = LocalStack()
current_app = LocalProxy(_find_app)
request = LocalProxy(partial(_lookup_req_object, 'request')) #reuqest是LocalProxy的對象，設(shè)置和獲取request對象中的屬性通過LocalProxy定義的各種雙下劃線實(shí)現(xiàn)
session = LocalProxy(partial(_lookup_req_object, 'session'))
g = LocalProxy(partial(_lookup_app_object, 'g')) 

from flask import Flask,_request_ctx_stack

app=Flask(__name__)

@app.route("/")
def hello():
  print(_request_ctx_stack.top.request.method) #結(jié)果GET,等價(jià)于request.method
  return 'this is wd'

if __name__=='__main__':
  app.run()