# the best timer function for the platform if sys.platform == 'win32': _timer = time.clock else: _timer = time.time try: from flask import _app_ctx_stack except ImportError: _app_ctx_stack = None # 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 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 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)
# -*- 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')
""" This file creates event notification signals for Flask-User. Signals are based on Flask.signals which are based on the blinker signals. :copyright: (c) 2013 by Ling Thio :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
def custom_signal(): ns = Namespace() custom_sig = ns.signal("custom_signal") custom_sig.connect = Mock() return custom_sig
url = factory.Faker('url') description = factory.Faker('text') 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 __init__(self): self.space = Namespace() self.events = {}
from flask.signals import Namespace model_signals = Namespace() app_signals = Namespace() model_user_new = model_signals.signal('model-user-new') model_user_edited = model_signals.signal('model-user-edited') model_user_deleted = model_signals.signal('model-user-deleted') model_org_new = model_signals.signal('model-org-new') model_org_edited = model_signals.signal('model-org-edited') model_org_deleted = model_signals.signal('model-org-deleted') model_team_new = model_signals.signal('model-team-new') model_team_edited = model_signals.signal('model-team-edited') model_team_deleted = model_signals.signal('model-team-deleted') model_useremail_new = model_signals.signal('model-useremail-new') model_useremail_edited = model_signals.signal('model-useremail-edited') model_useremail_deleted = model_signals.signal('model-useremail-deleted') model_useremailclaim_new = model_signals.signal('model-useremail-new') model_useremailclaim_edited = model_signals.signal('model-useremail-edited') model_useremailclaim_deleted = model_signals.signal('model-useremail-deleted') model_userphone_new = model_signals.signal('model-useremail-new') model_userphone_edited = model_signals.signal('model-useremail-edited') model_userphone_deleted = model_signals.signal('model-useremail-deleted') model_userphoneclaim_new = model_signals.signal('model-useremail-new') model_userphoneclaim_edited = model_signals.signal('model-useremail-edited')
.. data:: dockerflow.flask.signals.heartbeat_failed The signal that is sent when the heartbeat checks raise either a warning or worse (error, critical) Both signals receive an additional ``level`` parameter that indicates the maximum check level that failed during the rendering. E.g. to hook into those signals to send data to statsd, do this: .. code-block:: python from dockerflow.flask.signals import heartbeat_passed, heartbeat_failed from myproject.stats import statsd @heartbeat_passed.connect_via(app) def heartbeat_passed_handler(sender, level, **extra): statsd.incr('heartbeat.pass') @heartbeat_failed.connect_via(app) def heartbeat_failed_handler(sender, level, **extra): statsd.incr('heartbeat.fail') """ from flask.signals import Namespace dockerflow_signals = Namespace() heartbeat_passed = dockerflow_signals.signal('heartbeat-passed') heartbeat_failed = dockerflow_signals.signal('heartbeat-failed')
class Api(object): """Docstring for Api. """ MAX_PAGE_SIZE_CONFIG = 'MAX_PAGE_SIZE' MAX_PAGE_SIZE_DEFAULT = 100 _signal = Namespace() @property def max_page_size(self): return self.app.config.get(self.MAX_PAGE_SIZE_CONFIG, self.MAX_PAGE_SIZE_DEFAULT) def __init__(self, app, version=None, root='/api', encode=None, filter_builder=None): """TODO: to be defined1. :app: TODO :encode: function accepting one argument, returning tuple of 2 values - first is value encodable by json encoder or original object and second if value was encoded by function """ self.version = version self.root = root self.encoder_cls = self.get_encoder_cls(encode) if filter_builder: self.filter_builder = filter_builder else: self.filter_builder = FilterBuilder() self.api_error_signal = self._signal.signal('api-error') self.before_response_encoding_signal = self._signal.signal( 'before-response-encoding') self.init_app(app) @staticmethod def _str_to_type(value, value_type): pass def _filter_from_dict(self, filter_data, field_type): return {} def _catch_api_error(self, e): self.api_error_signal.send(self, error=e) details = [] if e.messages: details = e.messages error = self.get_error(e.message, details, e.error_code) return self.json_response(error, e.error_code) def _set_page_size(self): page_size = flask.request.args.get('page_size') if page_size is None: page_size = self.max_page_size else: try: page_size = int(page_size) except ValueError: raise errors.ApiError('`page_size` should be positive integer', 400) page_size = min(page_size, self.max_page_size) if page_size < 1: raise errors.ApiError('`page_size` should be positive integer', 400) flask.g.api.page_size = page_size def _set_page(self): page = 0 if 'page' in flask.request.args: try: page = int(flask.request.args['page']) - 1 except ValueError: raise errors.ApiError('`page` should be positive integer', 400) if page < 0: raise errors.ApiError('`page` should be positive integer', 400) flask.g.api.page = page def _set_order_by(self, allowed_fields): field = flask.request.args.get('order_by') if not field: flask.g.api.order_by = None else: if field.startswith('-'): flask.g.api.order_by = Sorting(field[1:], True) else: flask.g.api.order_by = Sorting(field, False) if flask.g.api.order_by.field not in allowed_fields: flask.g.api.order_by = None def _set_filter(self, validator, filter_types): if not validator: flask.g.api.filter = None return request_filter = self.filter_builder.filter_from_request(filter_types) if not validator.validate(request_filter): validator_errors = [] for prop, error in validator.errors.items(): validator_errors.append({prop: error}) raise errors.ApiError('Incorrect filter format', 400, messages=validator_errors) flask.g.api.filter = validator.document def register_api_data(self): flask.g.api = ApiData() def init_app(self, app): app.api = self self.app = app self.app.before_request(self.register_api_data) self.app.register_error_handler(errors.ApiError, self._catch_api_error) def get_encoder_cls(self, encode): class CustomEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, decimal.Decimal): return float(obj) elif isinstance(obj, date): return obj.isoformat() elif isinstance(obj, datetime): if not obj.tzinfo: obj = obj.replace(tzinfo=dateutil.tz.tzutc()) return obj.isoformat() elif isinstance(obj, set): return list(obj) elif encode: obj, ok = encode(obj) if ok: return obj return json.JSONEncoder.default(self, obj) return CustomEncoder def get_path(self, path): if self.version: return '{root}/{version}{path}'.format(root=self.root, version=self.version, path=path) else: return '{root}{path}'.format(root=self.root, path=path) def get_error(self, message, details=None, code=400): """TODO: Docstring for get_error. :message: TODO :details: TODO :returns: TODO """ details = details or [] return {'message': message, 'details': details, 'code': code} def json_response(self, data, code): data = json.dumps(data, cls=self.encoder_cls) response = flask.make_response(data, code) response.mimetype = 'application/json' return response def register_checked_json(self, validator=None, json_required=True, json_data=None): if json_data is None: if flask.request.is_json: json_data = flask.request.get_json() elif not flask.request.is_json and json_required: raise errors.ApiError('JSON data expected', 400) else: json_data = {} if validator: if not validator.validate(json_data): validator_errors = [] for prop, error in validator.errors.items(): validator_errors.append({prop: error}) raise errors.ApiError('Incorrect data format', 400, messages=validator_errors) json_data = validator.document flask.g.api.json = json_data def endpoint(self, path, method): ApiDoc.set_wrapper_endpoint(path, method) ApiDoc.add_wrapper_props({'method': method}) def wrapper(f): @self.app.route(self.get_path(path), methods=[method]) @wraps(f) def endpoint(*args, **kwargs): response = f(*args, **kwargs) self.before_response_encoding_signal.send(self) if not isinstance(response, flask.Response): response = self.json_response(response, 200) return response return wrapper def get(self, path): ApiDoc.set_wrapper_endpoint(path, 'GET') ApiDoc.add_wrapper_props({'method': 'GET'}) return self.endpoint(path, 'GET') def list(self, path, order_by=None, filters=None): """page based pagination """ ApiDoc.set_wrapper_endpoint(path, 'GET') ApiDoc.add_wrapper_props({ 'method': 'GET', 'list': True, 'order_by': order_by, 'filters': filters }) filter_validator = None if order_by is None: order_by = set() if filters: filter_validator = Validator( self.filter_builder.get_filter_schema(filters)) if filters is None: filters = {} def wrapper(f): @wraps(f) def f_wrapper(*args, **kwargs): self._set_page_size() self._set_page() self._set_order_by(order_by) self._set_filter(filter_validator, filters) result = f(*args, **kwargs) if isinstance(result, Page): response_data = {'data': result.get_items()} if result.has_count(): response_data['total'] = result.get_count() return response_data else: return { 'data': result, } return self.get(path)(f_wrapper) return wrapper def iterate(self, path, order_by=None, filters=None): """cursor based pagination """ ApiDoc.set_wrapper_endpoint(path, 'GET') ApiDoc.add_wrapper_props({ 'method': 'GET', 'list': True, 'order_by': order_by, 'filters': filters }) filter_validator = None if order_by is None: order_by = set() if filters: filter_validator = Validator( self.filter_builder.get_filter_schema(filters)) if filters is None: filters = {} def wrapper(f): @wraps(f) def f_wrapper(*args, **kwargs): self._set_page_size() self._set_order_by(order_by) self._set_filter(filter_validator, filters) flask.g.api.cursor = flask.request.args.get('next') result, cursor = f(*args, **kwargs) if isinstance(result, Page): response_data = {'data': result.get_items, 'next': cursor} if result.has_count(): response_data['total'] = result.get_count() return response_data else: return {'data': result, 'next': cursor} return self.get(path)(f_wrapper) return wrapper def post(self, path, schema=None): ApiDoc.set_wrapper_endpoint(path, 'POST') ApiDoc.add_wrapper_props({'method': 'POST', 'schema': schema}) validator = None if schema: validator = Validator(schema, purge_unknown=True) def wrapper(f): @wraps(f) def f_wrapper(*args, **kwargs): flask.g.api.schema = schema self.register_checked_json(validator) return f(*args, **kwargs) return self.endpoint(path, 'POST')(f_wrapper) return wrapper def upload(self, path, schema=None): ApiDoc.set_wrapper_endpoint(path, 'POST') ApiDoc.add_wrapper_props({ 'method': 'POST', 'file_upload': True, 'schema': schema }) validator = None if schema: validator = Validator(schema, purge_unknown=True) def wrapper(f): @wraps(f) def f_wrapper(*args, **kwargs): flask.g.api.schema = schema if 'data' in flask.request.form: json_data = json.loads(flask.request.form['data']) else: json_data = {} self.register_checked_json(validator, json_data=json_data) return f(*args, **kwargs) return self.endpoint(path, 'POST')(f_wrapper) return wrapper def put(self, path, schema=None): ApiDoc.set_wrapper_endpoint(path, 'PUT') ApiDoc.add_wrapper_props({'method': 'PUT', 'schema': schema}) validator = None if schema: validator = Validator(schema, purge_unknown=True) def wrapper(f): @wraps(f) def f_wrapper(*args, **kwargs): flask.g.api.schema = schema self.register_checked_json(validator, json_required=False) return f(*args, **kwargs) return self.endpoint(path, 'PUT')(f_wrapper) return wrapper def delete(self, path): ApiDoc.set_wrapper_endpoint(path, 'DELETE') ApiDoc.add_wrapper_props({ 'method': 'DELETE', }) def wrapper(f): @wraps(f) def f_wrapper(*args, **kwargs): result = f(*args, **kwargs) if result is None: return {} return result return self.endpoint(path, 'DELETE')(f_wrapper) return wrapper def doc(self, description): ApiDoc.add_wrapper_props({'description': description}) def wrapper(f): return f return wrapper
# Copyright (C) 2017 Boris Raicheff # All rights reserved # import hashlib import hmac import warnings import clearbit import itsdangerous from flask import abort, request, url_for from flask.signals import Namespace from six.moves.http_client import BAD_REQUEST, OK clearbit_result = Namespace().signal('clearbit.result') class Clearbit(object): """ Flask-Clearbit Documentation: https://flask-clearbit.readthedocs.io API: https://clearbit.com/docs?python :param app: Flask app to initialize with. Defaults to `None` :param blueprint: Blueprint to attach the webhook handler to. Defaults to `None` """
from flask.signals import Namespace _potion = Namespace() before_create = _potion.signal('before-create') after_create = _potion.signal('after-create') before_update = _potion.signal('before-update') after_update = _potion.signal('after-update') before_delete = _potion.signal('before-delete') after_delete = _potion.signal('after-delete') before_add_to_relation = _potion.signal('before-add-to-relation') after_add_to_relation = _potion.signal('after-add-to-relation') before_remove_from_relation = _potion.signal('before-remove-from-relation') after_remove_from_relation = _potion.signal('after-remove-from-relation')
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')
import logging from typing import List from blinker import Signal from dependency_injector.wiring import inject, Provide from flask.signals import Namespace from pydas_metadata.contexts import BaseContext from pydas_metadata.models import EventHandler from pydas.containers import ApplicationContainer from pydas.signals.type import SignalType pydas_events = Namespace() class SignalFactory: """API server signalling factory. Attributes ---------- signals: List[:class:`metadata.models.EventHandler`] Collection of event handlers that are registered with the server. pre_acquisition: blinker.Signal Signal object for pre-acquisition event handling. pre_company: blinker.Signal Signal object for pre-company event handling. pre_feature: blinker.Signal
from flask.signals import Namespace from flask.blueprints import Blueprint from kazoo.client import KazooClient from kazoo.security import make_digest_acl try: # noinspection PyProtectedMember from flask import _app_ctx_stack as stack except ImportError: # noinspection PyProtectedMember from flask import _request_ctx_stack as stack __all__ = ('FlaskZookeeperClient', ) connection_state_changed = Namespace().signal('state-change') class FlaskZookeeperClient(object): def __init__(self, app=None): self.uuid = str(uuid.uuid4()) self.app = None self.blueprint = None self.blueprint_setup = None if app is not None: self.app = app self.init_app(app) def init_app(self, app): if isinstance(app, Blueprint):