class GlobalsModule(types.ModuleType): __all__ = ('_dataset_ctx_stack', 'dataset', 'data', 'aggregation', 'resource') __package__ = __package__ __loader__ = __loader__ __name__ = __name__ __path__ = __file__ if '__initializing__' in locals(): __initializing__ = __initializing__ _dataset_ctx_stack = LocalStack() _resource_ctx_stack = LocalStack() def __init__(self, *args, **kwargs): super(GlobalsModule, self).__init__(*args, **kwargs) self.dataset = LocalProxy(self._lookup_dataset) self.data = LocalProxy(self._lookup_data_mapping) self.aggregation = LocalProxy(self._lookup_data_aggregation) self.resource = LocalProxy(self._lookup_resource_stack) def _lookup_resource_stack(self): top = self._resource_ctx_stack.top if top is None: raise RuntimeError('working outside of resource context') return top def _lookup_dataset(self): top = self._dataset_ctx_stack.top if top is None: raise RuntimeError('working outside of dataset context') return top def _lookup_data_mapping(self): return self.dataset.g def _lookup_data_aggregation(self): return self.data.aggregation def _lookup_named_graph(self, name): return self.data[name] def __getattr__(self, name): from werkzeug.local import LocalProxy from functools import partial if name not in self.__dict__: self.__dict__[name] = LocalProxy( partial(self._lookup_named_graph, name)) return self.__dict__[name]
def declare(self, token): self.guard.acquire() try: if token not in self.locals: self.locals[token] = LocalStack() return StackProxy(self, token) finally: self.guard.release()
def localstack_demo(): ls = LocalStack() a = ls.push(100) # a.pop() b = ls.push(120) print(a, b) print(ls.pop()) print(ls.pop())
def test_local(): """測試線程""" def get_item(): return test_stack.pop() test_stack = LocalStack() test_stack.push({'abc': '123'}) test_stack.push({'abc': '1234'}) item = get_item() print(item['abc']) print(item['abc']) test_stack = LocalStack() test_stack.push({'abc': '123'}) test_stack.push({'abc': '1234'}) item = LocalProxy(get_item) print(item['abc']) print(item['abc'])
def __init__(self): self.__url_map = Map([ Rule('/', endpoint='hello') # Rule('/<short_id>', endpoint='follow_short_link'), # Rule('/<short_id>+', endpoint='short_link_details') ]) self.logger = loadLogging(self.logger) self.is_run = False self.__view_functions = dict() self.__localstack = LocalStack() self.__read_config()
def test_local_stack(): """ 函数的代理 """ ls = LocalStack() for i in range(10): ls.push(i) def get_num(): return ls.pop() # LocalProxy 每次调用get_num函数, 并返回 lp = LocalProxy(get_num) for _ in range(10): print(lp)
def local_proxy_test1(): from werkzeug.local import LocalStack user_stack = LocalStack() user_stack.push({'name': 'Bob'}) user_stack.push({'name': 'John'}) def get_user(): # do something to get User object and return it return user_stack.pop() # 直接调用函数获取user对象 user = get_user() print user['name'] print user['name']
def local_proxy_test2(): from werkzeug.local import LocalStack, LocalProxy user_stack = LocalStack() user_stack.push({'name': 'Bob'}) user_stack.push({'name': 'John'}) def get_user(): # do something to get User object and return it return user_stack.pop() # 通过LocalProxy使用user对象 user = LocalProxy(get_user) print user['name'] print user['name']
def test_coroutine_localstack(self): ctx = LocalStack() patch_local(ctx) @coroutine def other_context(): ctx.push(45) return ctx.top ctx.push(40) fut = asyncio.ensure_future(other_context()) yield from fut self.assertEqual(ctx.top, 40) self.assertNotEqual(ctx.top, fut.result()) self.assertEqual(fut.result(), 45)
def test1(): stack = LocalStack() stack.push(1) stack.push(2) stack.push(3) stack.push(4) stack.push(5) print(stack.pop()) print(stack.pop()) print(stack.pop()) print(stack.pop()) print(stack.pop()) print(stack.pop()) print(stack.pop())
class Connection(object): __ctx = LocalStack() def __getattr__(self, name): if self.__ctx.top is None: self.connect() return getattr(self.__ctx.top, name) def connect(self): if self.__ctx.top is None: db = Database( name=settings.DATABASE_NAME, host=settings.DATABASE_HOST, port=settings.DATABASE_PORT, user=settings.DATABASE_USER, password=settings.DATABASE_PASSWORD) self.__ctx.push(db) self.__ctx.top.connect() def close(self): if self.__ctx.top is not None: self.__ctx.top.close() self.__ctx.pop()
# This file is part of Flask-PluginEngine. # Copyright (C) 2014-2017 CERN # # Flask-PluginEngine is free software; you can redistribute it # and/or modify it under the terms of the Revised BSD License. from werkzeug.local import LocalStack, LocalProxy _plugin_ctx_stack = LocalStack() #: Proxy to the currently active plugin current_plugin = LocalProxy(lambda: _plugin_ctx_stack.top)
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) # 从这个开始的4个,都是全局变量,他们其实通过代理上下文来实现的 # request = LocalProxy(_request_ctx_stack.top.request) = LocalProxy (_request_ctx_stack._local[stack][-1].request) request = LocalProxy(partial(_lookup_req_object, 'request')) session = LocalProxy(partial(_lookup_req_object, 'session')) g = LocalProxy(partial(_lookup_app_object, 'g'))
from wsgiref.simple_server import make_server from werkzeug.wrappers import Request as RequestBase, Response as ResponseBase from werkzeug.local import LocalStack, LocalProxy import re import logging as log import json _request_context_stack = LocalStack() request = LocalProxy(lambda: _request_context_stack.top.request) class Request(RequestBase): def __init__(self, environ): RequestBase.__init__(self, environ) class Response(ResponseBase): default_mimetype = 'text/html' class RequestContext(object): def __init__(self, environ): self.request = Request(environ) self.response = Response() def __enter__(self): _request_context_stack.push(self) def __exit__(self, exc_type, exc_val, exc_tb): _request_context_stack.pop()
""":mod:`kinsumer.globals` --- Defines all the global contexts ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ """ from functools import partial from werkzeug.local import LocalProxy, LocalStack def __lookup_shard_object(name): top = _shard_ctx_stack.top if top is None: raise RuntimeError('Working outside of shard context.') return getattr(top, name) def __find_consumer(): top = _consumer_ctx_stack.top if top is None: raise RuntimeError('Working outside of consumer context.') return top.consumer _shard_ctx_stack = LocalStack() _consumer_ctx_stack = LocalStack() current_consumer = LocalProxy(__find_consumer) shard = LocalProxy(partial(__lookup_shard_object, 'shard'))
class Context(LocalStack): pass def _lookup_context(): top = _context_stack.top if top is None: raise RuntimeError('Working outside of browser context.') return top def _copy_or_create_context(): if _context_stack.top: return copy(_context_stack.top) else: return Context() @contextmanager def browser_context(): context = _copy_or_create_context() _context_stack.push(context) try: yield finally: _context_stack.pop() _context_stack = LocalStack() context = LocalProxy(_lookup_context)
from flask.signals import template_rendered, request_started, request_finished from webtest import (TestApp as BaseTestApp, TestRequest as BaseTestRequest, TestResponse as BaseTestResponse) try: from flask_sqlalchemy import connection_stack except ImportError: connection_stack = None try: # Available starting with Flask 0.10 from flask.signals import message_flashed except ImportError: message_flashed = None _session_scope_stack = LocalStack() class SessionScope(object): """Session scope, being pushed, changes the value of :func:`.scopefunc` and, as a result, calls to `db.session` are proxied to the new underlying session. When popped, removes the current session and swap the value of :func:`.scopefunc` to the one that was before. :param db: :class:`flask_sqlalchemy.SQLAlchemy` instance """ def __init__(self, db): self.db = db def push(self):
if self in r: self._handle_request_noblock() 当有请求进来后触发处理当前请求的逻辑,这是调用__call__的第一步 但其绑定是在run方法中的run_simple中 """ print("environ:", environ) print("start_response:", start_response) return self.wsgi_app(environ, start_response) ################################################################### # 全局上下文变量定义(context locals) # 说明: # - 此处全局的 g, session, 需要深入理解 # - 需要深入去看 werkzeug.LocalStack() 的实现 Local-->LocalStack-->LocalProxy 这三个的关系参考下面的链接 # https://www.jianshu.com/p/3f38b777a621,https://blog.csdn.net/barrysj/article/details/51519254 # python中有threading local处理方式,在多线程环境中将变量按照线程id区分,由于协程在Python web中广泛使用,所以threading local不再满足需要 # local中优先使用greenlet协程,其次是线程id。localstack相当于在本协程(线程)中将数据以stack的形式存储(通过封装local来实现)。 # LocalProxy就是local的代理。重载了很多运算符,方便变量值得动态更新和获取, # ################################################################### _request_ctx_stack = LocalStack() # 依赖 werkzeug.LocalStack 模块-->`Local`堆栈 current_app = LocalProxy(lambda: _request_ctx_stack.top.app) request = LocalProxy(lambda: _request_ctx_stack.top.request) # - g: 请求上下文 栈对象 # - session: 请求上下文 栈对象 session = LocalProxy(lambda: _request_ctx_stack.top.session) # flash()函数中引用 g = LocalProxy(lambda: _request_ctx_stack.top.g)
""" Created by ZZXUN on 2018/8/6 """ import threading import time from werkzeug.local import Local, LocalStack __author__ = "ZZXUN" class A: b = 1 my_job = LocalStack() my_job.push(1) # 两个线程实例化两个栈,彼此数据不干扰 def worker(): print("in new thread before push, value is :" + str(my_job.top)) my_job.push(2) print("in new thread after push, value is :" + str(my_job.top)) new_t = threading.Thread(target=worker, name="zzx") new_t.start() time.sleep(1)
from werkzeug.local import LocalProxy, LocalStack from jinja2 import BaseLoader, ChoiceLoader, TemplateNotFound from flask import current_app, json, request as flask_request, _app_ctx_stack from . import verifier from . import logger from .convert import to_date, to_time, to_timedelta import collections import random request = LocalProxy(lambda: current_app.ask.request) session = LocalProxy(lambda: current_app.ask.session) version = LocalProxy(lambda: current_app.ask.version) context = LocalProxy(lambda: current_app.ask.context) convert_errors = LocalProxy(lambda: current_app.ask.convert_errors) current_stream = LocalStack() _converters = {'date': to_date, 'time': to_time, 'timedelta': to_timedelta} class Ask(object): """The Ask object provides the central interface for interacting with the Alexa service. Ask object maps Alexa Requests to flask view functions and handles Alexa sessions. The constructor is passed a Flask App instance, and URL endpoint. The Flask instance allows the convienient API of endpoints and their view functions, so that Alexa requests may be mapped with syntax similar to a typical Flask server. Route provides the entry point for the skill, and must be provided if an app is given. Keyword Arguments: app {Flask object} -- App instance - created with Flask(__name__) (default: {None})
print(f'In {current_thread().name} {obj.__ident_func__()} obj.a is', obj.a) def manipulate(): obj.a = 2 print(f'In {current_thread().name} {obj.__ident_func__()} obj.a is', obj.a) newThread = Thread(name='newThread', target=manipulate) newThread.start() time.sleep(1) print(f'In {current_thread().name} {obj.__ident_func__()} obj.a is', obj.a) # 线程隔离栈的试验 stk = LocalStack() stk.push(1) print(f'In {current_thread().name} {stk._local.__ident_func__()} stk.top is', stk.top) def manipulateStack(): print( f'In {current_thread().name} {stk._local.__ident_func__()} stk.top is', stk.top) newTread2 = Thread(name='newThread2', target=manipulateStack) newTread2.start() time.sleep(1)
# coding=utf-8 import random from flask import Flask, g, render_template from chapter3.section3.ext import db from chapter3.section3.users import User from werkzeug.local import LocalProxy, LocalStack app = Flask(__name__, template_folder='../../templates') app.config.from_object('chapter3.section3.config') db.init_app(app) _user_stack = LocalStack() def get_current_user(): top = _user_stack.top if top is None: raise RuntimeError() return top current_user = LocalProxy(get_current_user) @app.before_first_request def setup(): db.drop_all() db.create_all() fake_users = [ User('xiaoming'), User('dongqihong'),
# -*- coding: utf-8 -*- """ Created by Cphayim at 2018/6/27 23:20 """ import threading import time from werkzeug.local import LocalStack __author__ = 'Cphayim' my_stack = LocalStack() my_stack.push(1) print('in main thread after push, value is: ' + str(my_stack.top)) def worker(): # 新线程 print('in new thread before push, value is: ' + str(my_stack.top)) my_stack.push(2) print('in new thread after push, value is: ' + str(my_stack.top)) new_t = threading.Thread(target=worker, name='q') new_t.start() time.sleep(1) # 主线程 print('finally, in main thread value is: ' + str(my_stack.top))
from contextlib import contextmanager from functools import wraps from werkzeug.local import LocalProxy, LocalStack _additional_ctx_stack = LocalStack() __all__ = ("current_additions", "Additional", "AdditionalManager") @LocalProxy def current_additions(): """ Proxy to the currently added requirements """ rv = _additional_ctx_stack.top if rv is None: return None return rv[1] def _isinstance(f): @wraps(f) def check(self, other): if not isinstance(other, Additional): return NotImplemented return f(self, other) return check
return self.__dict__.pop(name, default) def setdefault(self, name, default=None): return self.__dict__.setdefault(name, default) def __contains__(self, item): return item in self.__dict__ def __iter__(self): return iter(self.__dict__) ##################################################################### # application context _app_ctx_stack = LocalStack() def _lookup_app_object(name): top = _app_ctx_stack.top if top is None: raise RuntimeError("Working outside of application context.") return getattr(top, name) class AppContext(object): def __init__(self, app): self.app = app self.g = _AppCtxGlobals() def __enter__(self):
import time import traceback from contextlib import contextmanager import click from click import style from werkzeug.local import LocalProxy from werkzeug.local import LocalStack _reporter_stack = LocalStack() _build_buffer_stack = LocalStack() def describe_build_func(func): self = getattr(func, "__self__", None) if self is not None and any(x.__name__ == "BuildProgram" for x in self.__class__.__mro__): return self.__class__.__module__ + "." + self.__class__.__name__ return func.__module__ + "." + func.__name__ class Reporter(object): def __init__(self, env, verbosity=0): self.env = env self.verbosity = verbosity self.builder_stack = [] self.artifact_stack = [] self.source_stack = [] def push(self):
from contextlib import contextmanager from jinja2 import Undefined from werkzeug.local import LocalStack, LocalProxy from lektor.reporter import reporter _ctx_stack = LocalStack() def url_to(*args, **kwargs): """Calculates a URL to another record.""" ctx = get_ctx() if ctx is None: raise RuntimeError('No context found') return ctx.url_to(*args, **kwargs) def get_asset_url(asset): """Calculates the asset URL relative to the current record.""" ctx = get_ctx() if ctx is None: raise RuntimeError('No context found') asset = site_proxy.get_asset(asset) if asset is None: return Undefined('Asset not found') info = ctx.build_state.get_file_info(asset.source_filename) return '%s?h=%s' % ( ctx.source.url_to('!' + asset.url_path), info.checksum[:8], )
def get_app_ctx_obj(name): top = _app_ctx_content.top if top is None: raise RuntimeError(app_ctx_error_msg) return getattr(top, name) def get_current_app(): top = _app_ctx_content.top if top is None: raise RuntimeError(app_ctx_error_msg) return top.app def has_app_ctx(): return _app_ctx_content.top is not None def has_request_ctx(): return _request_ctx_content.top is not None _request_ctx_content = LocalStack() _app_ctx_content = LocalStack() request = LocalProxy(partial(get_request_obj, 'request')) session = LocalProxy(partial(get_request_obj, 'session')) g = LocalProxy(partial(get_app_ctx_obj, 'g')) current_app = LocalProxy(get_current_app)
from werkzeug.local import LocalStack l = LocalStack() l.push(42) l.push(23) l.pop()
=============================== """ from functools import partial from werkzeug.local import LocalProxy, LocalStack class _SharedRequestClass(object): pass def _lookUpObjectInRequestContext(name): top = _requestContextStack.top if top is None: raise RuntimeError('ahixi...') return getattr(top, name) def findApp(): top = _appContextStack.top if top is None: raise RuntimeError('AppContext is none...') return top.app _requestContextStack = LocalStack() _appContextStack = LocalStack() currentApp = LocalProxy(findApp) request = LocalProxy(partial(_lookUpObjectInRequestContext, 'request')) session = LocalProxy(partial(_lookUpObjectInRequestContext, 'session')) shared = LocalProxy(partial(_lookUpObjectInRequestContext, 'shared'))