免费视频淫片aa毛片_日韩高清在线亚洲专区vr_日韩大片免费观看视频播放_亚洲欧美国产精品完整版

def _lookup_req_object(name):

   top = _request_ctx_stack.top

   if top is None:

       raise RuntimeError(_request_ctx_err_msg)

   return getattr(top, name)

def _lookup_app_object(name):

   top = _app_ctx_stack.top

   if top is None:

       raise RuntimeError(_app_ctx_err_msg)

   return getattr(top, name)

def _find_app():

   top = _app_ctx_stack.top

   if top is None:

       raise RuntimeError(_app_ctx_err_msg)

   return top.app

# context locals

_request_ctx_stack = LocalStack()

_app_ctx_stack = LocalStack()

current_app = LocalProxy(_find_app)

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

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

g = LocalProxy(partial(_lookup_app_object, 'g'))

# since each thread has its own greenlet we can just use those as identifiers

# for the context.  If greenlets are not available we fall back to the

# current thread ident depending on where it is.

try:

   from greenlet import getcurrent as get_ident

except ImportError:

   try:

       from thread import get_ident

   except ImportError:

       from _thread import get_ident

class Local(object):

   __slots__ = ('__storage__', '__ident_func__')

   def __init__(self):

       # 數(shù)據(jù)保存在 __storage__ 中，后續(xù)訪問都是對該屬性的操作

       object.__setattr__(self, '__storage__', {})

       object.__setattr__(self, '__ident_func__', get_ident)

   def __call__(self, proxy):

       '''Create a proxy for a name.'''

       return LocalProxy(self, proxy)

   # 清空當(dāng)前線程/協(xié)程保存的所有數(shù)據(jù)

   def __release_local__(self):

       self.__storage__.pop(self.__ident_func__(), None)

   # 下面三個(gè)方法實(shí)現(xiàn)了屬性的訪問、設(shè)置和刪除。

   # 注意到，內(nèi)部都調(diào)用 `self.__ident_func__` 獲取當(dāng)前線程或者協(xié)程的 id，然后再訪問對應(yīng)的內(nèi)部字典。

   # 如果訪問或者刪除的屬性不存在，會(huì)拋出 AttributeError。

   # 這樣，外部用戶看到的就是它在訪問實(shí)例的屬性，完全不知道字典或者多線程/協(xié)程切換的實(shí)現(xiàn)

   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)

class LocalStack(object):

   '''This class works similar to a :class:`Local` but keeps a stack

   of objects instead. '''

   def __init__(self):

       self._local = Local()

   def __release_local__(self):

       self._local.__release_local__()

   def __call__(self):

       def _lookup():

           rv = self.top

           if rv is None:

               raise RuntimeError('object unbound')

           return rv

       return LocalProxy(_lookup)

   # push、pop 和 top 三個(gè)方法實(shí)現(xiàn)了棧的操作，

   # 可以看到棧的數(shù)據(jù)是保存在 self._local.stack 屬性中的

   def push(self, obj):

       '''Pushes a new item to the stack'''

       rv = getattr(self._local, 'stack', None)

       if rv is None:

           self._local.stack = rv = []

       rv.append(obj)

       return rv

   def pop(self):

       '''Removes the topmost item from the stack, will return the

       old value or `None` if the stack was already empty.

       '''

       stack = getattr(self._local, 'stack', None)

       if stack is None:

           return None

       elif len(stack) == 1:

           release_local(self._local)

           return stack[-1]

       else:

           return stack.pop()

   @property

   def top(self):

       '''The topmost item on the stack.  If the stack is empty,

       `None` is returned.

       '''

       try:

           return self._local.stack[-1]

       except (AttributeError, IndexError):

           return None

_request_ctx_stack = LocalStack()

class LocalProxy(object):

   '''Acts as a proxy for a werkzeug local.

   Forwards all operations to a proxied object. '''

   __slots__ = ('__local', '__dict__', '__name__')

   def __init__(self, local, name=None):

       object.__setattr__(self, '_LocalProxy__local', local)

       object.__setattr__(self, '__name__', name)

   def _get_current_object(self):

       '''Return the current object.'''

       if not hasattr(self.__local, '__release_local__'):

           return self.__local()

       try:

           return getattr(self.__local, self.__name__)

       except AttributeError:

           raise RuntimeError('no object bound to %s' % self.__name__)

   @property

   def __dict__(self):

       try:

           return self._get_current_object().__dict__

       except RuntimeError:

           raise AttributeError('__dict__')

   def __getattr__(self, name):

       if name == '__members__':

           return dir(self._get_current_object())

       return getattr(self._get_current_object(), name)

   def __setitem__(self, key, value):

       self._get_current_object()[key] = value

_request_ctx_stack = LocalStack()

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

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

ctx = self.request_context(environ)

ctx.push()

def request_context(self, environ):

   return RequestContext(self, environ)

class RequestContext(object):

   '''The request context contains all request relevant information.  It is

   created at the beginning of the request and pushed to the

   `_request_ctx_stack` and removed at the end of it.  It will create the

   URL adapter and request object for the WSGI environment provided.

   '''

   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.match_request()

   def match_request(self):

       '''Can be overridden by a subclass to hook into the matching

       of the request.

       '''

       try:

           url_rule, self.request.view_args = \

               self.url_adapter.match(return_rule=True)

           self.request.url_rule = url_rule

       except HTTPException as e:

           self.request.routing_exception = e

   def push(self):

       '''Binds the request context to the current context.'''

       # Before we push the request context we have to ensure that there

       # is an application context.

       app_ctx = _app_ctx_stack.top

       if app_ctx is None or app_ctx.app != self.app:

           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)

       _request_ctx_stack.push(self)

       self.session = self.app.open_session(self.request)

       if self.session is None:

           self.session = self.app.make_null_session()

   def pop(self, exc=_sentinel):

       '''Pops the request context and unbinds it by doing that.  This will

       also trigger the execution of functions registered by the

       :meth:`~flask.Flask.teardown_request` decorator.

       '''

       app_ctx = self._implicit_app_ctx_stack.pop()

       try:

           clear_request = False

           if not self._implicit_app_ctx_stack:

               self.app.do_teardown_request(exc)

               request_close = getattr(self.request, 'close', None)

               if request_close is not None:

                   request_close()

               clear_request = True

       finally:

           rv = _request_ctx_stack.pop()

           # get rid of circular dependencies at the end of the request

           # so that we don't require the GC to be active.

           if clear_request:

               rv.request.environ['werkzeug.request'] = None

           # Get rid of the app as well if necessary.

           if app_ctx is not None:

               app_ctx.pop(exc)

   def auto_pop(self, exc):

       if self.request.environ.get('flask._preserve_context') or \

          (exc is not None and self.app.preserve_context_on_exception):

           self.preserved = True

           self._preserved_exc = exc

       else:

           self.pop(exc)

   def __enter__(self):

       self.push()

       return self

   def __exit__(self, exc_type, exc_value, tb):

       self.auto_pop(exc_value)

from werkzeug.wsgi import DispatcherMiddleware

from frontend_app import application as frontend

from backend_app import application as backend

application = DispatcherMiddleware(frontend, {

   '/backend':     backend

})

from flask import current_app

app = create_app()

admin_app = create_admin_app()

def do_something():

   with app.app_context():

       work_on(current_app)

       with admin_app.app_context():

           work_on(current_app)