# 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):
