Python local.LocalProxy方法代碼示例

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def add_token(request: LocalProxy, session: Session) -> str:
    """
    Create a new token for the user or return a
    valid existing token to the user.
    """
    token = None
    id_ = int(request.authorization['username'])
    try:
        token = session.query(Token).filter(Token.user_id == id_).one()
        if not token.is_valid():
            update_token = '%030x' % randrange(16**30)
            token.id = update_token
            token.timestamp = datetime.now()
            session.commit()
    except NoResultFound:
        token = '%030x' % randrange(16**30)
        new_token = Token(user_id=id_, id=token)
        session.add(new_token)
        session.commit()
        return token
    return token.id 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def __init__(self, signing_secret, endpoint, emitter, server):
        self.signing_secret = signing_secret
        self.emitter = emitter
        self.endpoint = endpoint
        self.package_info = self.get_package_info()

        # If a server is passed in, bind the event handler routes to it,
        # otherwise create a new Flask instance.
        if server:
            if isinstance(server, (Flask, Blueprint, LocalProxy)):
                self.bind_route(server)
            else:
                raise TypeError("Server must be an instance of Flask, Blueprint, or LocalProxy")
        else:
            Flask.__init__(self, __name__)
            self.bind_route(self) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def send_email(template, recipient, subject, **kwargs):
    # Convert database model instances to serializable dicts
    new_kwargs = {}
    for k, v in kwargs.items():
        if isinstance(v, UuidMixin):
            new_kwargs[k] = {
                'clz': type(v).__name__,
                'uuid': v.uuid,
            }
        elif isinstance(v, LocalProxy) and isinstance(v._get_current_object(), UuidMixin):
            new_kwargs[k] = {
                'clz': type(v._get_current_object()).__name__,
                'uuid': v.uuid,
            }
        else:
            new_kwargs[k] = v

    if current_app.config.get('RQ_ENABLED'):
        # Enqueue the message to send by the RQ worker
        send_email_queued.queue(template, recipient, subject, **new_kwargs)
    else:
        # Do the work during the request
        send_email_queued(template, recipient, subject, **new_kwargs) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def task(*args, **kwargs):
    """Register the decorated method as a celery task; use this just like
    app.task."""
    def inner(**kwargs):
        def wrap(fn):
            _defined_tasks[fn] = kwargs
            return LocalProxy(lambda: current_app.celery_tasks[fn])
        return wrap
    # remainder of this function is adapted from celery/app/base.py
    # (BSD-licensed)
    if len(args) == 1:
        if callable(args[0]):
            return inner(**kwargs)(*args)
        raise TypeError('argument 1 to @task() must be a callable')
    if args:
        raise TypeError(
            '@db.task() takes exactly 1 argument ({0} given)'.format(
                sum([len(args), len(kwargs)])))
    return inner(**kwargs) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def flask_request_to_dict_request(flask_request: LocalProxy) -> dict:
    """Convert flask request to dict request."""
    urllib_url = urlparse(flask_request.url)

    return {
        'headers': dict(flask_request.headers),
        'method': flask_request.method,
        'url': {
            'scheme': urllib_url.scheme,
            'netloc': urllib_url.netloc,
            'path': urllib_url.path,
            'params': urllib_url.params,
            'query': dict(parse_qsl(urllib_url.query)),
            'fragment': urllib_url.fragment
        },
        'body': dict(flask_request.json) if flask_request.json else {}
    } 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def check_nonce(request: LocalProxy, session: Session) -> bool:
    """check validity of nonce passed by the user."""
    try:
        id_ = request.headers['X-Authentication']
        nonce = session.query(Nonce).filter(Nonce.id == id_).one()
        present = datetime.now()
        present = present - nonce.timestamp
        session.delete(nonce)
        session.commit()
        if present > timedelta(0, 0, 0, 0, 1, 0, 0):
            return False
    except BaseException:
        return False
    return True 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def check_token(request: LocalProxy, session: Session) -> bool:
    """
    check validity of the token passed by the user.
    """
    token = None
    try:
        id_ = request.headers['X-Authorization']
        token = session.query(Token).filter(Token.id == id_).one()
        if not token.is_valid():
            token.delete()
            return False
    except BaseException:
        return False
    return True 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def check_authorization(request: LocalProxy, session: Session) -> bool:
    """Check if the request object has the correct authorization."""
    auth = request.authorization
    if check_nonce(request, session):
        return authenticate_user(auth.username, auth.password, session)
    return False 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def context_manager(self):
        """LocalProxy refering to the app's instance of the  :class: `ContextManager`.

        Interface for adding and accessing contexts and their parameters
        """
        return getattr(
            _app_ctx_stack.top, "_assist_context_manager", ContextManager(self)
        ) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def send_mail(subject, recipient, template, **context):
    """Send an email.

    :param subject: Email subject
    :param recipient: Email recipient
    :param template: The name of the email template
    :param context: The context to render the template with
    """

    context.setdefault("security", _security)
    context.update(_security._run_ctx_processor("mail"))

    body = None
    html = None
    ctx = ("security/email", template)
    if config_value("EMAIL_PLAINTEXT"):
        body = _security.render_template("%s/%s.txt" % ctx, **context)
    if config_value("EMAIL_HTML"):
        html = _security.render_template("%s/%s.html" % ctx, **context)

    sender = _security.email_sender
    if isinstance(sender, LocalProxy):
        sender = sender._get_current_object()

    _security._mail_util.send_mail(
        template, subject, recipient, str(sender), body, html, context.get("user", None)
    ) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def is_local_proxy(obj) -> bool:
    return isinstance(obj, (WerkzeugLocalProxy, QuartLocalProxy)) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def __call__(self):
        def _lookup():
            rv = self.top
            if rv is None:
                raise RuntimeError("object unbound")
            return rv

        return LocalProxy(_lookup) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def stream_proxy(original):
    def p():
        frame = inspect.currentframe()
        while frame:
            if frame.f_code == ThreadingMixIn.process_request_thread.__code__:
                return fake_stream()
            frame = frame.f_back
        return thread_proxies.get(currentThread().ident,
                                  original)

    return LocalProxy(p) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def send_mail_async(msg):
    if isinstance(msg.sender, LocalProxy):
        msg.sender = msg.sender._get_current_object()
    return send_mail_async_task.delay(msg) 

# 需要導入模塊: from werkzeug import local [as 別名]
# 或者: from werkzeug.local import LocalProxy [as 別名]
def freeze(object_or_proxy):
    """Get current object of `object_or_proxy` if it is LocalProxy"""
    if isinstance(object_or_proxy, LocalProxy):
        return object_or_proxy._get_current_object()
    return object_or_proxy