class EventManager:
def __init__(self):
self.space = Namespace()
self.events = {}
def trigger(self, event_name, **params):
if self.events.get(event_name) is None:
return
self.events[event_name].send(current_app._get_current_object(),
**params)
def subscribe(self, event_name):
if self.events.get(event_name) is None:
self.events[event_name] = self.space.signal(event_name)
return self.events[event_name].connect
class Signals(object):
def __init__(self):
self._signals = Namespace()
#General Commands
self.execute_commands = self._signals.signal("execute_commands")
#Post Signals
self.new_post = self._signals.signal("post-new")
self.save_post = self._signals.signal("post-save")
self.delete_post = self._signals.signal("post-delete")
#Thread Signals
self.prune_thread = self._signals.signal("prune")
#Image Signals
self.new_image = self._signals.signal("image-new")
self.delete_image = self._signals.signal("image-delete")
#Ban Signals
self.new_ban = self._signals.signal("ban-new")
import copy
from flask import _app_ctx_stack
from flask.signals import Namespace
from sqlalchemy import orm
from sqlalchemy.event import listen
from wowhua_db.api.util import get_scoped_session as get_api_session
from wowhua_db.admin.util import get_scoped_session as get_admin_session
# migrated from flask_sqlalchemy
_signals = Namespace()
models_committed = _signals.signal('models-committed')
class SignallingSession(orm.Session):
def __init__(self, **options):
super(SignallingSession, self).__init__(**options)
self._model_changes = {}
class _SessionSignalEvents(object):
def register(self, app):
self.app = app
listen(SignallingSession, 'after_commit',
self.session_signal_after_commit)
def session_signal_after_commit(self, session):
d = session._model_changes
if d:
models_committed.send(self.app, changes=d.values())
d.clear()
from flask.signals import Namespace
PY3 = sys.version_info[0] == 3
signals = Namespace()
identity_changed = signals.signal('identity-changed', doc="""
Signal sent when the identity for a request has been changed.
Actual name: ``identity-changed``
Authentication providers should send this signal when authentication has been
successfully performed. Flask-Principal connects to this signal and
causes the identity to be saved in the session.
For example::
from flaskext.principal import Identity, identity_changed
def login_view(req):
username = req.form.get('username')
# check the credentials
identity_changed.send(app, identity=Identity(username))
""")
identity_loaded = signals.signal('identity-loaded', doc="""
Signal sent when the identity has been initialised for a request.
Actual name: ``identity-loaded``
from . import config
from flask import current_app, request
from flask.signals import Namespace
from .version import __version__
class SSOAttributeError(Exception):
"""General SSO Attribute error."""
# Signals
_signals = Namespace()
sso_logged_in = _signals.signal('sso-logged-in')
"""Sent when a user is logged in.
In addition to the app (which is the sender), it is passed `user`, which is
the user being logged in.
"""
class SSO(object):
"""Flask extension implementation."""
def __init__(self, app=None):
"""Initialize login callback."""
self.login_callback = None
self.login_error_callback = None
if app is not None:
from __future__ import absolute_import
from __future__ import unicode_literals
from flask.signals import Namespace
_signals = Namespace()
# Call when application initializations is completed.
# Sender will be the application instance.
app_ready = _signals.signal('app-ready')
config_ready = _signals.signal('config-ready')
testing_run_start = _signals.signal('testing-run-start')
db_clear_pre = _signals.signal('db-clear-pre')
db_clear_post = _signals.signal('db-clear-post')
db_init_pre = _signals.signal('db-init-pre')
db_init_post = _signals.signal('db-init-post')
from flask.signals import Namespace
namespace = Namespace()
pre_action = namespace.signal('pre-action')
post_action = namespace.signal('post-action')
EXTENSION_NAME = "FeatureFlags"
class StopCheckingFeatureFlags(Exception):
""" Raise this inside of a feature flag handler to immediately return False and stop any further handers from running """
pass
class NoFeatureFlagFound(Exception):
""" Raise this when the feature flag does not exist. """
pass
_ns = Namespace()
missing_feature = _ns.signal('missing-feature')
def AppConfigFlagHandler(feature=None):
""" This is the default handler. It checks for feature flags in the current app's configuration.
For example, to have 'unfinished_feature' hidden in production but active in development:
config.py
class ProductionConfig(Config):
FEATURE_FLAGS = {
'unfinished_feature' : False,
}
from flask import g, session, current_app, abort, request
from flask.signals import Namespace
signals = Namespace()
identity_changed = signals.signal('identity-changed',
doc="""
Signal sent when the identity for a request has been changed.
Actual name: ``identity-changed``
Authentication providers should send this signal when authentication has been
successfully performed. Flask-Principal connects to this signal and
causes the identity to be saved in the session.
For example::
from flaskext.principal import Identity, identity_changed
def login_view(req):
username = req.form.get('username')
# check the credentials
identity_changed.send(app, identity=Identity(username))
""")
identity_loaded = signals.signal('identity-loaded',
doc="""
Signal sent when the identity has been initialised for a request.
Actual name: ``identity-loaded``
except ImportError:
_app_ctx_stack = None
__version__ = "3.0-dev"
# Which stack should we use? _app_ctx_stack is new in 0.9
connection_stack = _app_ctx_stack or _request_ctx_stack
_camelcase_re = re.compile(r"([A-Z]+)(?=[a-z0-9])")
_signals = Namespace()
models_committed = _signals.signal("models-committed")
before_models_committed = _signals.signal("before-models-committed")
def _make_table(db):
def _make_table(*args, **kwargs):
if len(args) > 1 and isinstance(args[1], db.Column):
args = (args[0], db.metadata) + args[1:]
info = kwargs.pop("info", None) or {}
info.setdefault("bind_key", None)
kwargs["info"] = info
return sqlalchemy.Table(*args, **kwargs)
return _make_table
from urllib.parse import quote
from urllib.parse import urljoin
from urllib.parse import urlencode
try:
from urllib import urlopen
except ImportError:
from urllib.request import urlopen
try:
import simplejson as json
except ImportError:
import json
_signals = Namespace()
wx_userinfo_fetched = _signals.signal("wx-userinfo-fetched")
blueprint = flask.Blueprint("wx_auth", __name__)
@blueprint.route("/authorize")
def authorize():
auth_url = WXOAuth2.create_authorize_url(redirect_uri=url_for(".callback", _external=True))
return flask.redirect(auth_url)
@blueprint.route("/callback")
def callback():
code = flask.request.args.get("code", None)
if not code:
return flask.redirect(url_for(current_app.config["WX_OAUTH2_REFUSED_ROUTE"]))
from datetime import datetime
import json
from bson.objectid import ObjectId
from ext.auth.helpers import Helpers
from ext.notifications.email import Email # , Sms
# TIME & DATE - better with arrow only?
import arrow
_signals = Namespace()
# Define signals
signal_activity_log = _signals.signal('user-activity-logger')
signal_insert_workflow = _signals.signal('insert-workflow')
signal_change_owner = _signals.signal('change-owner')
signal_change_acl = _signals.signal('change-acl')
signal_init_acl = _signals.signal('init-acl')
@signal_insert_workflow.connect
def insert_workflow(dict_app, **extra):
""" Inserts workflow, wathcers, owner, reporter and custom id on the current resource
Only when method equals POST
@todo: need resource->workflow mapping
@todo: should hook into the given workflow (from mapping?)and retrieve schema OR schema is fixed
@todo: generic means it can find what to do for each resource (mappings?)
@TODO: Should really init the state machine in transitions to do this!
"""
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from flask.signals import Namespace
ns = Namespace()
#: Sent when a metric needs to be updated
metric_need_update = ns.signal('metric:need-update')
#: Sent when a metric has been updated
metric_updated = ns.signal('metric:updated')
from . import config
from flask import current_app, request
from flask.signals import Namespace
class SSOAttributeError(Exception):
pass
# Signals
_signals = Namespace()
#: Sent when a user is logged in. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged in.
sso_logged_in = _signals.signal('sso-logged-in')
class SSO(object):
"""
Flask extension
Initialization of the extension:
>>> from flask import Flask
>>> from flask_sso import SSO
>>> app = Flask('myapp')
>>> ext = SSO(app=app)
or alternatively using the factory pattern:
from flask.signals import Namespace
from flask.ext.sqlalchemy import SQLAlchemy
from raven.contrib.flask import Sentry
sentry = Sentry()
db = SQLAlchemy()
db_signals = Namespace()
db_created = db_signals.signal('created')
from collections import OrderedDict
except ImportError:
from ordereddict import OrderedDict
from coaster.utils import getbool
from coaster.views import get_current_url, get_next_url
from flask import session, g, redirect, url_for, request, flash, abort, Response, jsonify, json, current_app
from flask.signals import Namespace
from . import translations
from ._version import * # NOQA
# Signals
lastuser_signals = Namespace()
signal_user_session_refreshed = lastuser_signals.signal('user-session-refreshed')
signal_user_session_expired = lastuser_signals.signal('user-session-expired')
signal_user_looked_up = lastuser_signals.signal('user-looked-up')
signal_before_wrapped_view = lastuser_signals.signal('before-wrapped-view')
# Translations
flask_lastuser_translations = Domain(translations.__path__[0], domain='flask_lastuser')
_ = flask_lastuser_translations.gettext
__ = flask_lastuser_translations.lazy_gettext
# Bearer token, as per http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-15#section-2.1
auth_bearer_re = re.compile("^Bearer ([a-zA-Z0-9_.~+/-]+=*)$")
class LastuserConfigException(Exception):
pass
if key in app.config:
self.config[key] = app.config[key]
self.app = app
def config_from_env(self):
for key in self.config:
self.config[key] = os.environ.get(key, self.config[key])
def send(self, message):
if not message.from_email:
message.set_from(self.config['MAIL_DEFAULT_SENDER'])
# send signal
email_dispatched.send(
current_app._get_current_object(), message=message)
if self.app and self.app.testing:
return
status, reason = self.sg.send(message)
if status == 200:
return status, reason
else:
raise SendEmailError('{}: {}'.format(status, message))
signals = Namespace()
email_dispatched = signals.signal("email-dispatched", doc="""
Signal sent when an email is dispatched. This signal will also be sent
in testing mode, even though the email will not actually be sent.
""")
flask_login.signals
-------------------
This module provides signals to get notified when Flask-Login performs
certain actions.
"""
from flask.signals import Namespace
_signals = Namespace()
#: Sent when a user is logged in. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged in.
user_logged_in = _signals.signal("logged-in")
#: Sent when a user is logged out. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged out.
user_logged_out = _signals.signal("logged-out")
#: Sent when the user is loaded from the cookie. In addition to the app (which
#: is the sender), it is passed `user`, which is the user being reloaded.
user_loaded_from_cookie = _signals.signal("loaded-from-cookie")
#: Sent when the user is loaded from the header. In addition to the app (which
#: is the #: sender), it is passed `user`, which is the user being reloaded.
user_loaded_from_header = _signals.signal("loaded-from-header")
#: Sent when the user is loaded from the request. In addition to the app (which
#: is the #: sender), it is passed `user`, which is the user being reloaded.
from __future__ import absolute_import
from __future__ import unicode_literals
from flask.signals import Namespace
_signals = Namespace()
# Call when application initializations is completed.
# Sender will be the application instance.
app_ready = _signals.signal('app-ready')
config_ready = _signals.signal('config-ready')
testing_run_start = _signals.signal('testing-run-start')
from flask.signals import Namespace
__all__ = ['request_token_fetched']
_signals = Namespace()
request_token_fetched = _signals.signal('request-token-fetched')
from sqlalchemy import event
from flask import g
from .core import SignallingSessionPlus as Session
from flask.signals import Namespace
from ..utils import (set_if_absent_and_get, append_if_absent, flatten,
ist_now)
from decimal import Decimal
db_signals = Namespace()
out_of_stock = db_signals.signal('out_of_stock')
shipment_status_change = db_signals.signal('shipment_status_change')
customer_init = db_signals.signal('customer_init')
def all_subclasses(cls):
return cls.__subclasses__() + [
g for s in cls.__subclasses__() for g in all_subclasses(s)]
def add_to_record(key, item, struct=g):
append_if_absent(set_if_absent_and_get(struct, key, []), item)
class EventListener:
def __init__(self, app=None):
self.app = app
if app:
self.initialize_listeners()
def is_active(self):
return False
def is_anonymous(self):
return True
def get_id(self):
return None
# Signals
#: Sent when a user is logged in. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged in.
user_logged_in = _signals.signal("logged-in")
#: Sent when a user is logged out. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged out.
user_logged_out = _signals.signal("logged-out")
#: Sent when a user's login is confirmed, marking it as fresh. (It is not
#: called for a normal login.)
#: It receives no additional arguments besides the app.
user_login_confirmed = _signals.signal("login-confirmed")
#: Sent when the `unauthorized` method is called on a `LoginManager`. It
#: receives no additional arguments besides the app.
user_unauthorized = _signals.signal("unauthorized")
#: Sent when the `needs_refresh` method is called on a `LoginManager`. It
import logging
from flask.signals import Namespace
log = logging.getLogger(__name__)
ns = Namespace()
#: Sent when a new HarvestSource is created
harvest_source_created = ns.signal('harvest:source-created')
#: Sent when a HarvestSource is updated
harvest_source_updated = ns.signal('harvest:source-updated')
#: Sent when a HarvestSource is deleted
harvest_source_deleted = ns.signal('harvest:source-deleted')
#: Run before each harvest job
before_harvest_job = ns.signal('harvest:before-job')
#: Run before each harvest job
after_harvest_job = ns.signal('harvest:after-job')
#: Sent when a new HarvestJob started
harvest_job_started = ns.signal('harvest:job-started')
#: Sent when a HarvestJob is done
harvest_job_done = ns.signal('harvest:job-done')
#: Sent when a HarvestJob failed
harvest_job_failed = ns.signal('harvest:job-failed')
from warnings import warn
from inspect import getargspec
from genshi.template import (NewTextTemplate, MarkupTemplate, loader,
TemplateLoader)
from werkzeug.utils import cached_property
from flask import current_app
try:
from flask import signals_available
except ImportError:
signals_available = False
else:
from flask.signals import Namespace
signals = Namespace()
template_generated = signals.signal('template-generated')
# there's more to Jinja context than just environment,
# but apparently the only thing jinja filters currently care about is this (and also whether autoescaping is on),
# hence these shims.
# XXX this does not take custom jinja filters into account, although I don't expect Genshi-minded users of @jinja2.contextfilter any time soon.
class FakeJinjaContext:
def __init__(self, env):
self.environment = env
class FakeJinjaEvalContext:
def __init__(self, env):
self.environment = env
# Flask set this one explicitly
# -*- coding: utf-8 -*-
from flask.signals import Namespace
baseframe_signals = Namespace()
form_validation_error = baseframe_signals.signal('form-validation-error')
form_validation_success = baseframe_signals.signal('form-validation-success')
exception_catchall = baseframe_signals.signal('exception-catchall')
def _secret_key(key=None):
if key is None:
key = current_app.config['SECRET_KEY']
if isinstance(key, unicode): # pragma: no cover
key = key.encode('latin1') # ensure bytes
return key
# Signals
#: Sent when a user is logged in. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged in.
user_logged_in = _signals.signal('logged-in')
#: Sent when a user is logged out. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged out.
user_logged_out = _signals.signal('logged-out')
#: Sent when the user is loaded from the cookie. In addition to the app (which
#: is the sender), it is passed `user`, which is the user being reloaded.
user_loaded_from_cookie = _signals.signal('loaded-from-cookie')
#: Sent when the user is loaded from the header. In addition to the app (which
#: is the #: sender), it is passed `user`, which is the user being reloaded.
user_loaded_from_header = _signals.signal('loaded-from-header')
#: Sent when a user's login is confirmed, marking it as fresh. (It is not
#: called for a normal login.)
from flask import current_app
from flask.signals import Namespace
applicationSingnals = Namespace()
onOrderRefunded = applicationSingnals.signal('order-refunded')
onOrderDiscounted = applicationSingnals.signal('order-discounted')
onOrderDiscountApproved = applicationSingnals.signal('order-discount-approved')
onOrderRefundApproved = applicationSingnals.signal('order-refund-approved')
onOrderDeleted = applicationSingnals.signal('order-deleted')
onOrderSerivceChanged = applicationSingnals.signal('order-service-changed')
onUserDeleted = applicationSingnals.signal('user-deleted')
onUserUpdated = applicationSingnals.signal('user-updated')
onUserCreated = applicationSingnals.signal('user-created')
onUserLoggedin = applicationSingnals.signal('user-loggedin')
onUserLogginAttempted = applicationSingnals.signal('user-login-attempted')
onSessionResetUsed = applicationSingnals.signal('session-reset-used')
onSessionResetLastUsed = applicationSingnals.signal('session-reset-last-used')
onSessionServiceChanged = applicationSingnals.signal('session-service-changed')
onPatientUpdated = applicationSingnals.signal('patient-updated')
onPatientDeleted = applicationSingnals.signal('patient-deleted')
onPatientCreated = applicationSingnals.signal('patient-created')
@onOrderRefunded.connect
def onOrderRefundedCallback(data, **kwargs):
pass
from __future__ import unicode_literals, print_function
import six
from lazy import lazy
from abc import ABCMeta, abstractmethod, abstractproperty
from distutils.version import StrictVersion
import flask
from flask.signals import Namespace
from flask_dance.consumer.backend.session import SessionBackend
from flask_dance.utils import Dictective, getattrd
_signals = Namespace()
oauth_authorized = _signals.signal('oauth-authorized')
oauth_error = _signals.signal('oauth-error')
class BaseOAuthConsumerBlueprint(six.with_metaclass(ABCMeta, flask.Blueprint)):
def __init__(self, name, import_name,
static_folder=None, static_url_path=None, template_folder=None,
url_prefix=None, subdomain=None, url_defaults=None, root_path=None,
login_url=None, authorized_url=None, backend=None):
bp_kwargs = dict(
name=name,
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
def custom_signal():
ns = Namespace()
custom_sig = ns.signal("custom_signal")
custom_sig.connect = Mock()
return custom_sig
from flask.signals import Namespace
import RPi.GPIO as GPIO
L1 = 14
L2 = 15
Len = 18
R1 = 23
R2 = 24
Ren = 25
namespace = Namespace()
robot_move = namespace.signal('robot_move')
robot_speed = namespace.signal('robot_speed')
def setupGPIO():
# mode
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
#L motor
GPIO.setup(L1, GPIO.OUT)
GPIO.output(L1, GPIO.LOW)
GPIO.setup(L2, GPIO.OUT)
GPIO.output(L2, GPIO.LOW)
GPIO.setup(Len, GPIO.OUT)
Lpwm = GPIO.PWM(Len, 1000)
Lpwm.start(25)
from inspect import getargspec
from genshi.template import (NewTextTemplate, MarkupTemplate,
loader, TemplateLoader)
from werkzeug import cached_property
import flask
from flask import current_app
try:
from flask import signals_available
except ImportError:
signals_available = False
else:
from flask.signals import Namespace
signals = Namespace()
template_generated = signals.signal('template-generated')
class Genshi(object):
"""Initialize extension.
::
app = Flask(__name__)
genshi = Genshi(app)
.. versionchanged:: 0.4
You can now initialize your application later with :meth:`init_app`.
.. deprecated:: 0.4
``app.genshi_instance`` in favor of ``app.extensions['genshi']``.
import datetime
from functools import partial
from flask.signals import Namespace
from flask.ext.sqlalchemy import SQLAlchemy, BaseQuery
from flask.ext.principal import Need, UserNeed
from flask.ext.cache import Cache
__all__ = [
'db', 'cache', 'YuanQuery', 'SessionMixin',
'model_created', 'model_updated', 'model_deleted',
'create_user_needs', 'TeamNeed',
]
signals = Namespace()
model_created = signals.signal('model-created')
model_updated = signals.signal('model-updated')
model_deleted = signals.signal('model-deleted')
db = SQLAlchemy()
cache = Cache()
TeamNeed = partial(Need, 'team')
def create_user_needs(owner_id, permission):
rv = db.session.execute(
'SELECT account_id FROM team_member '
'JOIN team ON team_member.team_id=team.id '
'AND team.owner_id=:id AND team._permission>:permission '
'GROUP BY account_id', {'id': owner_id, 'permission': permission})
return map(lambda o: UserNeed(o[0]), rv)
# -*- coding:utf-8 -*-
from flask.signals import Namespace
_signals = Namespace()
on_start = _signals.signal('on_start')
from werkzeug.local import LocalProxy
from flask import current_app
from flask.signals import Namespace
from kazoo.client import KazooClient
__all__ = ('Kazoo', )
__version__ = '0.1'
_signals = Namespace()
connection_state_changed = _signals.signal('state-change')
def _get_client():
kazoo_client = current_app._get_current_object().extensions['kazoo']['client']
return kazoo_client
kazoo_client = LocalProxy(_get_client)
class Kazoo(object):
"""Kazoo Client support for Flask."""
def __init__(self, app=None):
"""
If app argument provided then initialize cqlengine connection using
application config values.
class HarvestJobFactory(factory.mongoengine.MongoEngineFactory):
class Meta:
model = HarvestJob
created = dtfactory('-3h', '-2h')
started = dtfactory('-2h', '-1h')
ended = dtfactory('-1h', 'new')
status = FuzzyChoice(HarvestJob.status.choices)
source = factory.SubFactory(HarvestSourceFactory)
ns = Namespace()
mock_initialize = ns.signal('backend:initialize')
mock_process = ns.signal('backend:process')
DEFAULT_COUNT = 3
class FactoryBackend(backends.BaseBackend):
name = 'factory'
def initialize(self):
mock_initialize.send(self)
for i in range(self.config.get('count', DEFAULT_COUNT)):
self.add_item(i)
def process(self, item):
mock_process.send(self, item=item)
from flask import redirect, session
from flask import request as flask_req
from flask.signals import Namespace
from flask import _app_ctx_stack
from .._client import UserInfoMixin
from .._client import RemoteApp as _RemoteApp
__all__ = ['token_update', 'RemoteApp']
_signal = Namespace()
#: signal when token is updated
token_update = _signal.signal('token_update')
class RemoteApp(_RemoteApp, UserInfoMixin):
"""Flask integrated RemoteApp of :class:`~authlib.client.OAuthClient`.
It has built-in hooks for OAuthClient. The only required configuration
is token model.
"""
def __init__(self, name, fetch_token=None, **kwargs):
fetch_request_token = kwargs.pop('fetch_request_token', None)
save_request_token = kwargs.pop('save_request_token', None)
super(RemoteApp, self).__init__(name, fetch_token, **kwargs)
self._fetch_request_token = fetch_request_token
self._save_request_token = save_request_token
def _send_token_update(self, token, refresh_token=None, access_token=None):
self.token = token
super(RemoteApp, self)._send_token_update(token, refresh_token,
access_token)
from __future__ import unicode_literals, print_function
from datetime import datetime, timedelta
import six
from lazy import lazy
from abc import ABCMeta, abstractmethod, abstractproperty
from werkzeug.datastructures import CallbackDict
import flask
from flask.signals import Namespace
from flask_dance.consumer.backend.session import SessionBackend
from flask_dance.utils import getattrd, timestamp_from_datetime
_signals = Namespace()
oauth_authorized = _signals.signal("oauth-authorized")
oauth_before_login = _signals.signal("oauth-before-login")
oauth_error = _signals.signal("oauth-error")
class BaseOAuthConsumerBlueprint(six.with_metaclass(ABCMeta, flask.Blueprint)):
def __init__(
self,
name,
import_name,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
# License: Simplified BSD License, see LICENSE.txt for more details.
from flask.signals import Namespace
_signals = Namespace() # Place Flask-User signals in our own namespace
# *******************
# ** Flask Signals **
# *******************
# Flask signals are based on blinker. Neither Flask nor Flask-User installs blinker
# If you plan to use signals, please install blinker with 'pip install blinker'
# See http://flask.pocoo.org/docs/signals/
# Sent when a user changed their password
user_changed_password = _signals.signal('user.user_changed_password')
# Sent when a user changed their username
user_changed_username = _signals.signal('user.user_changed_username')
# Sent when a user confirmed their email
user_confirmed_email = _signals.signal('user.user_confirmed_email')
# Sent when a user submitted a password reset request
user_forgot_password = _signals.signal('user.forgot_password')
# Sent when a user logged in
user_logged_in = _signals.signal('user.user_logged_in')
# Sent when a user logged out
user_logged_out = _signals.signal('user.user_logged_out')
# register additional template commands
def url_for_other_page(page):
args = request.view_args.copy()
args['page'] = page
return url_for(request.endpoint, **args)
app.jinja_env.globals['url_for_other_page'] = url_for_other_page
#
# Blinker custom signals
#
signals = Namespace()
before_flush = signals.signal('models-before-flush')
# Add flush signalling to session, used to auto-calculate balance later on
class _CustomSessionSignalEvents(object):
def register(self):
sqla_event.listen(SQLA_SessionBase, 'before_flush',
self.session_signal_before_flush)
@staticmethod
def session_signal_before_flush(session, flush_context, instances):
before_flush.send(session.app, session=session, instances=instances)
class SQLAlchemy(SQLAlchemyBase):
def __init__(self,
'Removed connection to %(provider)s '
'account %(provider_user_id)s for %(user)s' % ctx)
do_flash("Connection to %(provider)s removed" % ctx, 'info')
except ConnectionNotFoundError:
current_app.logger.error(
'Unable to remove connection to %(provider)s account '
'%(provider_user_id)s for %(user)s' % ctx)
do_flash("Unabled to remove connection to %(provider)s" % ctx,
'error')
return redirect(request.referrer)
# Configure the URL handlers for each fo the configured providers
for provider_config in provider_configs:
_configure_provider(app, blueprint, app.oauth, provider_config)
url_prefix = app.config[URL_PREFIX_KEY]
app.register_blueprint(blueprint, url_prefix=url_prefix)
def do_flash(message, category):
if current_app.config[FLASH_MESSAGES_KEY]:
flash(message, category)
# Signals
social_connection_created = _signals.signal("connection-created")
social_login_failed = _signals.signal("login-failed")
# -*- coding: utf-8 -*-
from flask.signals import Namespace
from sqlalchemy import event as sqla_event
from .models import User, Organization, Team
lastuser_signals = Namespace()
model_user_new = lastuser_signals.signal('model-user-new')
model_user_edited = lastuser_signals.signal('model-user-edited')
model_user_deleted = lastuser_signals.signal('model-user-deleted')
model_org_new = lastuser_signals.signal('model-org-new')
model_org_edited = lastuser_signals.signal('model-org-edited')
model_org_deleted = lastuser_signals.signal('model-org-deleted')
model_team_new = lastuser_signals.signal('model-team-new')
model_team_edited = lastuser_signals.signal('model-team-edited')
model_team_deleted = lastuser_signals.signal('model-team-deleted')
resource_access_granted = lastuser_signals.signal('resource-access-granted')
# Higher level signals
user_login = lastuser_signals.signal('user-login')
user_logout = lastuser_signals.signal('user-logout')
user_registered = lastuser_signals.signal('user-registered')
user_data_changed = lastuser_signals.signal('user-data-changed')
org_data_changed = lastuser_signals.signal('org-data-changed')
team_data_changed = lastuser_signals.signal('team-data-changed')
from __future__ import unicode_literals, print_function
from datetime import datetime, timedelta
import six
from lazy import lazy
from abc import ABCMeta, abstractmethod, abstractproperty
from werkzeug.datastructures import CallbackDict
import flask
from flask.signals import Namespace
from flask_dance.consumer.backend.session import SessionBackend
from flask_dance.utils import getattrd, timestamp_from_datetime
_signals = Namespace()
oauth_authorized = _signals.signal('oauth-authorized')
oauth_error = _signals.signal('oauth-error')
class BaseOAuthConsumerBlueprint(six.with_metaclass(ABCMeta, flask.Blueprint)):
def __init__(self,
name,
import_name,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
authorized_url=None,
backend=None):
from flask.signals import _signals
custom_signal = _signals.signal('custom-signal')
- 将信号定义在自定的命名空间内
from flask.signals import Namespace
_signals = Namespace()
#: Sent when a user is logged in. In addition to the app (which is the sender), it is passed `user`, which is the user being logged in.
user_logged_in = _signals.signal('logged-in')
'''
# 实例化命名空间
_signal = Namespace()
# 自定义一个信号
customSignal = _signal.signal('custom-signal')
# 触发信号要执行的函数
def sig(*args, **kwargs):
# 可以接受send（）函数传入的参数
print(f'触发信号函数： {sig.__name__}， 参数：', args, kwargs)
# 设置信号触发的回调函数；
# 设置 receiver
customSignal.connect(sig)
@app.route("/")
def index():
return s.encode("latin-1")
else:
from cStringIO import StringIO as BytesIO
string_types = basestring,
from itertools import izip_longest as zip_longest
def b(s):
return s
# Signals
_signals = Namespace()
#: Sent when a sitemap index is generated and given page will need to be
#: generated in the future from already calculated url set.
sitemap_page_needed = _signals.signal('sitemap-page-needed')
class Sitemap(object):
"""Flask extension implementation."""
def __init__(self, app=None, force_domain=None):
"""Initialize login callback."""
self.decorators = []
self.url_generators = [self._routes_without_params]
if app is not None:
self.init_app(app, force_domain)
def init_app(self, app, force_domain=None):
"""Initialize a Flask application."""
# License, or (at your option) any later version.
#
# Invenio is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Invenio; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
"""Contain signals emitted from workflows module."""
from flask.signals import Namespace
_signals = Namespace()
workflow_halted = _signals.signal('workflow_halted')
"""
This signal is sent when a workflow engine's halt function is called.
Sender is the BibWorkflowObject that was running before the workflow
was halted.
"""
workflow_started = _signals.signal('workflow_started')
"""
This signal is sent when a workflow is started.
Sender is the workflow engine object running the workflow.
"""
workflow_finished = _signals.signal('workflow_finished')
"""
This signal is sent when a workflow is finished.
from flask.signals import Namespace
ns = Namespace()
#: Sent when a metric needs to be updated
metric_need_update = ns.signal('metric:need-update')
#: Sent when a metric has been updated
metric_updated = ns.signal('metric:updated')
#
# Flask-Airpbx
#
# Copyright (C) 2021 Airpbx Ltd
# All rights reserved
#
from flask.signals import Namespace
namespace = Namespace()
ping = namespace.signal('ping')
# EOF
from sqlalchemy import event
from sqlalchemy import inspect
from sqlalchemy import orm
from sqlalchemy.engine.url import make_url
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.declarative import DeclarativeMeta
from sqlalchemy.orm.exc import UnmappedClassError
from sqlalchemy.orm.session import Session as SessionBase
from .model import DefaultMeta
from .model import Model
__version__ = "3.0.0.dev"
_signals = Namespace()
models_committed = _signals.signal("models-committed")
before_models_committed = _signals.signal("before-models-committed")
def _make_table(db):
def _make_table(*args, **kwargs):
if len(args) > 1 and isinstance(args[1], db.Column):
args = (args[0], db.metadata) + args[1:]
info = kwargs.pop("info", None) or {}
info.setdefault("bind_key", None)
kwargs["info"] = info
return sqlalchemy.Table(*args, **kwargs)
return _make_table
#encoding:utf8
from flask.signals import Namespace
__all__ = [
"request_received", "request_deserialized", "request_badrequest",
"request_deserialize_error", "request_handle_error", "response_error",
"response_sent", "wechat_granted", "wechat_servererror", "wechat_error"
]
signals = Namespace()
request_received = signals.signal("request_received")
request_deserialized = signals.signal("request_deserialized")
request_badrequest = signals.signal("request_badrequest")
# request_deserialize_error = signals.signal("request_deserialize_error")
request_handle_error = signals.signal("request_handle_error")
# response_error = signals.signal("response_error")
response_sent = signals.signal("response_sent")
wechat_granted = signals.signal("wechat_granted")
wechat_servererror = signals.signal("wechat_servererror")
wechat_error = signals.signal("wechat_error")
def is_active(self):
return False
def is_anonymous(self):
return True
def get_id(self):
return None
# Signals
#: Sent when a user is logged in. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged in.
user_logged_in = _signals.signal("logged-in")
#: Sent when a user is logged out. In addition to the app (which is the
#: sender), it is passed `user`, which is the user being logged out.
user_logged_out = _signals.signal("logged-out")
#: Sent when a user's login is confirmed, marking it as fresh. (It is not
#: called for a normal login.)
#: It receives no additional arguments besides the app.
user_login_confirmed = _signals.signal("login-confirmed")
#: Sent when the `unauthorized` method is called on a `LoginManager`. It
#: receives no additional arguments besides the app.
user_unauthorized = _signals.signal("unauthorized")
#: Sent when the `needs_refresh` method is called on a `LoginManager`. It
:author: Ling Thio ([email protected]) :license: Simplified BSD License, see LICENSE.txt for more details.""" from flask.signals import Namespace _signals = Namespace() # Place Flask-User signals in our own namespace # ******************* # ** Flask Signals ** # ******************* # Flask signals are based on blinker. Neither Flask nor Flask-User installs blinker # If you plan to use signals, please install blinker with 'pip install blinker' # See http://flask.pocoo.org/docs/signals/ # Sent when a user changed their password user_changed_password = _signals.signal('user.user_changed_password') # Sent when a user changed their username user_changed_username = _signals.signal('user.user_changed_username') # Sent when a user confirmed their email user_confirmed_email = _signals.signal('user.user_confirmed_email') # Sent when a user submitted a password reset request user_forgot_password = _signals.signal('user.forgot_password') # Sent when a user logged in user_logged_in = _signals.signal('user.user_logged_in') # Sent when a user logged out user_logged_out = _signals.signal('user.user_logged_out')
from flask.signals import Namespace
# signals
signals = Namespace()
db_before_reset = signals.signal('db-before-reset')
db_reset_dropped = signals.signal('db-reset-dropped')
db_reset_created = signals.signal('db-reset-created')
db_after_reset = signals.signal('db-after-reset')
return s.encode("latin-1")
else:
from cStringIO import StringIO as BytesIO
string_types = basestring,
from itertools import izip_longest as zip_longest
def b(s):
return s
# Signals
_signals = Namespace()
#: Sent when a sitemap index is generated and given page will need to be
#: generated in the future from already calculated url set.
sitemap_page_needed = _signals.signal('sitemap-page-needed')
class Sitemap(object):
"""Flask extension implementation."""
def __init__(self, app=None):
"""Initialize login callback."""
self.decorators = []
self.url_generators = [self._routes_without_params]
if app is not None:
self.init_app(app)
def init_app(self, app):
"""Initialize a Flask application."""
from flask.signals import Namespace
__all__ = ['request_token_fetched']
_signals = Namespace()
request_token_fetched = _signals.signal('request-token-fetched')
#encoding:utf8
from flask.signals import Namespace
__all__ = ["request_received", "request_deserialized", "request_badrequest",
"request_deserialize_error", "request_handle_error", "response_error",
"response_sent", "wechat_granted", "wechat_servererror", "wechat_error"]
signals = Namespace()
request_received = signals.signal("request_received")
request_deserialized = signals.signal("request_deserialized")
request_badrequest = signals.signal("request_badrequest")
# request_deserialize_error = signals.signal("request_deserialize_error")
request_handle_error = signals.signal("request_handle_error")
# response_error = signals.signal("response_error")
response_sent = signals.signal("response_sent")
wechat_granted = signals.signal("wechat_granted")
wechat_servererror = signals.signal("wechat_servererror")
wechat_error = signals.signal("wechat_error")
from sqlalchemy.engine.url import make_url
from sqlalchemy.ext.declarative import declarative_base, DeclarativeMeta
from sqlalchemy.util import to_list
# the best timer function for the platform
if sys.platform == 'win32':
_timer = time.clock
else:
_timer = time.time
_camelcase_re = re.compile(r'([A-Z]+)(?=[a-z0-9])')
_signals = Namespace()
models_committed = _signals.signal('models-committed')
before_models_committed = _signals.signal('before-models-committed')
def _make_table(db):
def _make_table(*args, **kwargs):
if len(args) > 1 and isinstance(args[1], db.Column):
args = (args[0], db.metadata) + args[1:]
info = kwargs.pop('info', None) or {}
info.setdefault('bind_key', None)
return sqlalchemy.Table(*args, **kwargs)
return _make_table
def _set_default_query_class(d):
if 'query_class' not in d:
:author: Ling Thio ([email protected]) :license: Simplified BSD License, see LICENSE.txt for more details.""" from flask.signals import Namespace _signals = Namespace() # Place Flask-User signals in our own namespace """ ******************* ** Flask Signals ** ******************* Flask signals are based on blinker. Neither Flask nor Flask-User installs blinker If you plan to use signals, please install blinker with 'pip install blinker' See http://flask.pocoo.org/docs/signals/""" # Sent when a user changed their password user_changed_password = _signals.signal('user.user_changed_password') # Sent when a user changed their username user_changed_username = _signals.signal('user.user_changed_username') # Sent when a user changed their theme user_changed_theme = _signals.signal('user.user_changed_theme') # Sent when a user adds a tenant user_added_tenant = _signals.signal('user.user_added_tenant') # Sent when a user edits a tenant user_edited_tenant = _signals.signal('user.user_edited_tenant') # Sent when a user adds a tenant user user_added_tenant_user = _signals.signal('user.user_added_tenant_user')
_timer = time.time
try:
from flask import _app_ctx_stack
except ImportError:
_app_ctx_stack = None
__version__ = '2.0'
# Which stack should we use? _app_ctx_stack is new in 0.9
connection_stack = _app_ctx_stack or _request_ctx_stack
_camelcase_re = re.compile(r'([A-Z]+)(?=[a-z0-9])')
_signals = Namespace()
models_committed = _signals.signal('models-committed')
before_models_committed = _signals.signal('before-models-committed')
def _make_table(db):
def _make_table(*args, **kwargs):
if len(args) > 1 and isinstance(args[1], db.Column):
args = (args[0], db.metadata) + args[1:]
info = kwargs.pop('info', None) or {}
info.setdefault('bind_key', None)
kwargs['info'] = info
return sqlalchemy.Table(*args, **kwargs)
return _make_table
#
# Invenio is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Invenio; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
"""Contain signals emitted from workflows module."""
from flask.signals import Namespace
_signals = Namespace()
workflow_halted = _signals.signal('workflow_halted')
"""
This signal is sent when a workflow engine's halt function is called.
Sender is the BibWorkflowObject that was running before the workflow
was halted.
"""
workflow_started = _signals.signal('workflow_started')
"""
This signal is sent when a workflow is started.
Sender is the workflow engine object running the workflow.
"""
workflow_finished = _signals.signal('workflow_finished')
"""
This signal is sent when a workflow is finished.
