def connect_signals(app): appcontext_popped.connect(handle_appcontext_popped) appcontext_pushed.connect(handle_appcontext_pushed) appcontext_tearing_down.connect(handle_appcontext_tearing_down) before_render_template.connect(handle_before_render_template, app) got_request_exception.connect(handle_got_request_exception, app) request_finished.connect(handle_request_finished, app) request_started.connect(handle_request_started, sender=app, weak=True) request_tearing_down.connect(handle_request_tearing_down, app, False) template_rendered.connect(handle_template_rendered, sender=app)
def create_app(config_file): app = Flask(__name__) app.glados_config = read_config(config_file) if app.glados_config.config.ngrok.enabled: logging.debug("launching ngrok") # app.ngrok = setup_ngrok(app) register_views(app) setup_ngrok(app) appcontext_pushed.connect(setup_ngrok, app) appcontext_tearing_down.connect(teardown_ngrok, app) return app
def _context_callbacks(app, key, original_context=_CONTEXT_MISSING): """Register the callbacks we need to properly pop and push the app-local context for a component. Args: app (flask.Flask): The app who this context belongs to. This is the only sender our Blinker signal will listen to. key (str): The key on ``_CONTEXT_LOCALS`` that this app's context listens to. Kwargs: original_context (dict): The original context present whenever these callbacks were registered. We will restore the context to this value whenever the app context gets popped. Returns: (function, function): A two-element tuple of the dynamic functions we generated as appcontext callbacks. The first element is the callback for ``appcontext_pushed`` (i.e., get and store the current context) and the second element is the callback for ``appcontext_popped`` (i.e., restore the current context to to it's original value). """ def _get_context(dummy_app): """Set the context proxy so that it points to a specific context. """ _CONTEXT_LOCALS.context = _CONTEXT_LOCALS(key) # pylint: disable=assigning-non-slot def _clear_context(dummy_app): """Remove the context proxy that points to a specific context and restore the original context, if there was one. """ try: del _CONTEXT_LOCALS.context except AttributeError: pass if original_context is not _CONTEXT_MISSING: setattr(_CONTEXT_LOCALS, key, original_context) # store for later so Blinker doesn't remove these listeners and so we # don't add them twice _CONTEXT_CALLBACK_MAP[app] = (_get_context, _clear_context) # and listen for any app context changes appcontext_pushed.connect(_get_context, app) appcontext_popped.connect(_clear_context, app) return (_get_context, _clear_context)
def init_app(self, app): Service.init_app(self, app) state = app.extensions[self.name] whoosh_base = app.config.get("WHOOSH_BASE") if not whoosh_base: whoosh_base = "whoosh" # Default value if not os.path.isabs(whoosh_base): whoosh_base = os.path.join(app.instance_path, whoosh_base) state.whoosh_base = os.path.abspath(whoosh_base) if not self._listening: event.listen(Session, "after_flush", self.after_flush) event.listen(Session, "after_commit", self.after_commit) self._listening = True appcontext_pushed.connect(self.clear_update_queue, app) signals.register_js_api.connect(self._do_register_js_api)
def init_app(self, app): Service.init_app(self, app) state = app.extensions[self.name] whoosh_base = Path(app.config.get("WHOOSH_BASE", "whoosh")) if not whoosh_base.is_absolute(): whoosh_base = app.instance_path / whoosh_base if not whoosh_base.is_dir(): whoosh_base.mkdir(parents=True) state.whoosh_base = text_type(whoosh_base.resolve()) if not self._listening: event.listen(Session, "after_flush", self.after_flush) event.listen(Session, "after_commit", self.after_commit) self._listening = True appcontext_pushed.connect(self.clear_update_queue, app) signals.register_js_api.connect(self._do_register_js_api)
def init_app(self, app): Service.init_app(self, app) state = app.extensions[self.name] whoosh_base = Path(app.config.get("WHOOSH_BASE", "whoosh")) if not whoosh_base.is_absolute(): whoosh_base = app.instance_path / whoosh_base if not whoosh_base.is_dir(): whoosh_base.mkdir(parents=True) state.whoosh_base = str(whoosh_base.resolve()) if not self._listening: event.listen(Session, "after_flush", self.after_flush) event.listen(Session, "after_commit", self.after_commit) self._listening = True appcontext_pushed.connect(self.clear_update_queue, app) signals.register_js_api.connect(self._do_register_js_api)
def start(self): """ Starts the Application :return: """ appcontext_tearing_down.connect(self.stop, self.app) appcontext_pushed.connect(self.app_pushed, self.app) self.fake_module = Thread(target=run_fake_module, args=(self.startapp, self.runapp)) self.channels = Channels(self) self.channels.register_api() self.sensors = Sensors(self) # self.sensors.register_api() self.modules = Modules(self) self.modules.register_api() self.website = Website(self) self.website.register_url()
def __init__(self, name=None, config=None, *args, **kwargs): kwargs.setdefault('instance_relative_config', True) name = name or __name__ # used by make_config to determine if we try to load config from instance / # environment variable /... self._ABILIAN_INIT_TESTING_FLAG = (getattr(config, 'TESTING', False) if config else False) Flask.__init__(self, name, *args, **kwargs) del self._ABILIAN_INIT_TESTING_FLAG self._setup_script_manager() appcontext_pushed.connect(self._install_id_generator) ServiceManager.__init__(self) PluginManager.__init__(self) self.default_view = ViewRegistry() self.js_api = dict() if config: self.config.from_object(config) # at this point we have loaded all external config files: # SQLALCHEMY_DATABASE_URI is definitively fixed (it cannot be defined in # database AFAICT), and LOGGING_FILE cannot be set in DB settings. self.setup_logging() configured = bool(self.config.get('SQLALCHEMY_DATABASE_URI')) self.config['CONFIGURED'] = configured if not self.testing: self.init_sentry() if not configured: # set fixed secret_key so that any unconfigured worker will use, so that # session can be used during setup even if multiple processes are # processing requests. self.config['SECRET_KEY'] = 'abilian_setup_key' # time to load config bits from database: 'settings' # First init required stuff: db to make queries, and settings service extensions.db.init_app(self) settings_service.init_app(self) if configured: with self.app_context(): try: settings = self.services['settings'].namespace( 'config').as_dict() except sa.exc.DatabaseError as exc: # we may get here if DB is not initialized and "settings" table is # missing. Command "initdb" must be run to initialize db, but first we # must pass app init if not self.testing: # durint tests this message will show up on every test, since db is # always recreated logging.error(exc.message) self.db.session.rollback() else: self.config.update(settings) if not self.config.get('FAVICO_URL'): self.config['FAVICO_URL'] = self.config.get('LOGO_URL') languages = self.config.get('BABEL_ACCEPT_LANGUAGES') if languages is None: languages = abilian.i18n.VALID_LANGUAGES_CODE else: languages = tuple(lang for lang in languages if lang in abilian.i18n.VALID_LANGUAGES_CODE) self.config['BABEL_ACCEPT_LANGUAGES'] = languages self._jinja_loaders = list() self.register_jinja_loaders( jinja2.PackageLoader('abilian.web', 'templates')) js_filters = (('closure_js', ) if self.config.get('PRODUCTION', False) else None) self._assets_bundles = { 'css': { 'options': dict(filters=('less', 'cssmin'), output='style-%(version)s.min.css') }, 'js-top': { 'options': dict(output='top-%(version)s.min.js', filters=js_filters) }, 'js': { 'options': dict(output='app-%(version)s.min.js', filters=js_filters) }, } # bundles for JS translations for lang in languages: code = 'js-i18n-' + lang filename = 'lang-' + lang + '-%(version)s.min.js' self._assets_bundles[code] = { 'options': dict(output=filename, filters=js_filters), } for http_error_code in (403, 404, 500): self.install_default_handler(http_error_code) with self.app_context(): self.init_extensions() self.register_plugins() self.add_access_controller('static', allow_access_for_roles(Anonymous), endpoint=True) # debugtoolbar: this is needed to have it when not authenticated on a # private site. We cannot do this in init_debug_toolbar, since auth # service is not yet installed self.add_access_controller('debugtoolbar', allow_access_for_roles(Anonymous)) self.add_access_controller('_debug_toolbar.static', allow_access_for_roles(Anonymous), endpoint=True) self.maybe_register_setup_wizard() self._finalize_assets_setup() # At this point all models should have been imported: time to configure # mappers. Normally Sqlalchemy does it when needed but mappers may be # configured inside sa.orm.class_mapper() which hides a misconfiguration: if # a mapper is misconfigured its exception is swallowed by # class_mapper(model) results in this laconic (and misleading) message: # "model is not mapped" sa.orm.configure_mappers() signals.components_registered.send(self) self.before_first_request(self._set_current_celery_app) self.before_first_request(lambda: signals.register_js_api.send(self)) request_started.connect(self._setup_nav_and_breadcrumbs) # Initialize Abilian core services. # Must come after all entity classes have been declared. # Inherited from ServiceManager. Will need some configuration love later. if not self.config.get('TESTING', False): with self.app_context(): self.start_services()
def __init__(self, name=None, config=None, *args, **kwargs): name = name or __name__ instance_path = os.environ.get("FLASK_INSTANCE_PATH") if instance_path: kwargs["instance_path"] = instance_path else: kwargs.setdefault("instance_relative_config", True) # used by make_config to determine if we try to load config from # instance / environment variable /... self._ABILIAN_INIT_TESTING_FLAG = (getattr(config, "TESTING", False) if config else False) Flask.__init__(self, name, *args, **kwargs) del self._ABILIAN_INIT_TESTING_FLAG self._setup_script_manager() appcontext_pushed.connect(self._install_id_generator) ServiceManager.__init__(self) PluginManager.__init__(self) JinjaManagerMixin.__init__(self) self.default_view = ViewRegistry() self.js_api = dict() self.configure(config) # At this point we have loaded all external config files: # SQLALCHEMY_DATABASE_URI is definitively fixed (it cannot be defined in # database AFAICT), and LOGGING_FILE cannot be set in DB settings. self.setup_logging() configured = bool(self.config.get("SQLALCHEMY_DATABASE_URI")) self.config["CONFIGURED"] = configured if not self.testing: self.init_sentry() if not configured: # set fixed secret_key so that any unconfigured worker will use, # so that session can be used during setup even if # multiple processes are processing requests. self.config["SECRET_KEY"] = "abilian_setup_key" # time to load config bits from database: 'settings' # First init required stuff: db to make queries, and settings service extensions.db.init_app(self) settings_service.init_app(self) if configured: with self.app_context(): try: settings = self.services["settings"] config = settings.namespace("config").as_dict() except sa.exc.DatabaseError as exc: # We may get here if DB is not initialized and "settings" # table is missing. Command "initdb" must be run to # initialize db, but first we must pass app init. if not self.testing: # durint tests this message will show up on every test, # since db is always recreated logging.error(exc) db.session.rollback() else: self.config.update(config) if not self.config.get("FAVICO_URL"): self.config["FAVICO_URL"] = self.config.get("LOGO_URL") self.register_jinja_loaders(jinja2.PackageLoader("abilian.web")) self.init_assets() self.install_default_handlers() with self.app_context(): self.init_extensions() self.register_plugins() self.add_access_controller("static", allow_access_for_roles(Anonymous), endpoint=True) # debugtoolbar: this is needed to have it when not authenticated # on a private site. We cannot do this in init_debug_toolbar, # since auth service is not yet installed. self.add_access_controller("debugtoolbar", allow_access_for_roles(Anonymous)) self.add_access_controller( "_debug_toolbar.static", allow_access_for_roles(Anonymous), endpoint=True, ) self.maybe_register_setup_wizard() self._finalize_assets_setup() # At this point all models should have been imported: time to configure # mappers. Normally Sqlalchemy does it when needed but mappers may be # configured inside sa.orm.class_mapper() which hides a # misconfiguration: if a mapper is misconfigured its exception is # swallowed by class_mapper(model) results in this laconic # (and misleading) message: "model is not mapped" sa.orm.configure_mappers() signals.components_registered.send(self) self.before_first_request(self._set_current_celery_app) self.before_first_request(lambda: signals.register_js_api.send(self)) request_started.connect(self._setup_nav_and_breadcrumbs) # Initialize Abilian core services. # Must come after all entity classes have been declared. # Inherited from ServiceManager. Will need some configuration love # later. if not self.config.get("TESTING", False): with self.app_context(): self.start_services() if os.environ.get("FLASK_VALIDATE_HTML"): # Workaround circular import from abilian.testing.validation import validate_response self.after_request(validate_response)
def __init__(self, name=None, config=None, *args, **kwargs): kwargs.setdefault('instance_relative_config', True) name = name or __name__ # used by make_config to determine if we try to load config from instance / # environment variable /... self._ABILIAN_INIT_TESTING_FLAG = (getattr(config, 'TESTING', False) if config else False) Flask.__init__(self, name, *args, **kwargs) del self._ABILIAN_INIT_TESTING_FLAG self._setup_script_manager() appcontext_pushed.connect(self._install_id_generator) ServiceManager.__init__(self) PluginManager.__init__(self) self.default_view = ViewRegistry() self.js_api = dict() if config: self.config.from_object(config) # at this point we have loaded all external config files: # SQLALCHEMY_DATABASE_URI is definitively fixed (it cannot be defined in # database AFAICT), and LOGGING_FILE cannot be set in DB settings. self.setup_logging() configured = bool(self.config.get('SQLALCHEMY_DATABASE_URI')) self.config['CONFIGURED'] = configured if not self.testing: self.init_sentry() if not configured: # set fixed secret_key so that any unconfigured worker will use, so that # session can be used during setup even if multiple processes are # processing requests. self.config['SECRET_KEY'] = 'abilian_setup_key' # time to load config bits from database: 'settings' # First init required stuff: db to make queries, and settings service extensions.db.init_app(self) settings_service.init_app(self) if configured: with self.app_context(): try: settings = self.services['settings'].namespace('config').as_dict() except sa.exc.DatabaseError as exc: # we may get here if DB is not initialized and "settings" table is # missing. Command "initdb" must be run to initialize db, but first we # must pass app init if not self.testing: # durint tests this message will show up on every test, since db is # always recreated logging.error(exc.message) self.db.session.rollback() else: self.config.update(settings) if not self.config.get('FAVICO_URL'): self.config['FAVICO_URL'] = self.config.get('LOGO_URL') languages = self.config.get('BABEL_ACCEPT_LANGUAGES') if languages is None: languages = abilian.i18n.VALID_LANGUAGES_CODE else: languages = tuple(lang for lang in languages if lang in abilian.i18n.VALID_LANGUAGES_CODE) self.config['BABEL_ACCEPT_LANGUAGES'] = languages self._jinja_loaders = list() self.register_jinja_loaders( jinja2.PackageLoader('abilian.web', 'templates')) js_filters = (('closure_js',) if self.config.get('PRODUCTION', False) else None) self._assets_bundles = { 'css': {'options': dict(filters=('less', 'cssmin'), output='style-%(version)s.min.css',)}, 'js-top': {'options': dict(output='top-%(version)s.min.js', filters=js_filters,)}, 'js': {'options': dict(output='app-%(version)s.min.js', filters=js_filters)}, } # bundles for JS translations for lang in languages: code = 'js-i18n-' + lang filename = 'lang-' + lang + '-%(version)s.min.js' self._assets_bundles[code] = { 'options': dict(output=filename, filters=js_filters), } for http_error_code in (403, 404, 500): self.install_default_handler(http_error_code) with self.app_context(): self.init_extensions() self.register_plugins() self.add_access_controller('static', allow_access_for_roles(Anonymous), endpoint=True) # debugtoolbar: this is needed to have it when not authenticated on a # private site. We cannot do this in init_debug_toolbar, since auth # service is not yet installed self.add_access_controller('debugtoolbar', allow_access_for_roles(Anonymous),) self.add_access_controller('_debug_toolbar.static', allow_access_for_roles(Anonymous), endpoint=True) self.maybe_register_setup_wizard() self._finalize_assets_setup() # At this point all models should have been imported: time to configure # mappers. Normally Sqlalchemy does it when needed but mappers may be # configured inside sa.orm.class_mapper() which hides a misconfiguration: if # a mapper is misconfigured its exception is swallowed by # class_mapper(model) results in this laconic (and misleading) message: # "model is not mapped" sa.orm.configure_mappers() signals.components_registered.send(self) self.before_first_request(self._set_current_celery_app) self.before_first_request( lambda: signals.register_js_api.send(self) ) request_started.connect(self._setup_nav_and_breadcrumbs) # Initialize Abilian core services. # Must come after all entity classes have been declared. # Inherited from ServiceManager. Will need some configuration love later. if not self.config.get('TESTING', False): with self.app_context(): self.start_services()
def setup(self, config): self.configure(config) # At this point we have loaded all external config files: # SQLALCHEMY_DATABASE_URI is definitively fixed (it cannot be defined in # database AFAICT), and LOGGING_FILE cannot be set in DB settings. self.setup_logging() appcontext_pushed.connect(self.install_id_generator) if not self.testing: self.init_sentry() # time to load config bits from database: 'settings' # First init required stuff: db to make queries, and settings service extensions.db.init_app(self) settings_service.init_app(self) self.register_jinja_loaders(jinja2.PackageLoader("abilian.web")) self.init_assets() self.install_default_handlers() with self.app_context(): self.init_extensions() self.register_plugins() self.add_access_controller( "static", allow_access_for_roles(Anonymous), endpoint=True ) # debugtoolbar: this is needed to have it when not authenticated # on a private site. We cannot do this in init_debug_toolbar, # since auth service is not yet installed. self.add_access_controller( "debugtoolbar", allow_access_for_roles(Anonymous) ) self.add_access_controller( "_debug_toolbar.static", allow_access_for_roles(Anonymous), endpoint=True, ) # TODO: maybe reenable later # self.maybe_register_setup_wizard() self._finalize_assets_setup() # At this point all models should have been imported: time to configure # mappers. Normally Sqlalchemy does it when needed but mappers may be # configured inside sa.orm.class_mapper() which hides a # misconfiguration: if a mapper is misconfigured its exception is # swallowed by class_mapper(model) results in this laconic # (and misleading) message: "model is not mapped" sa.orm.configure_mappers() signals.components_registered.send(self) request_started.connect(self.setup_nav_and_breadcrumbs) init_hooks(self) # Initialize Abilian core services. # Must come after all entity classes have been declared. # Inherited from ServiceManager. Will need some configuration love # later. if not self.testing: with self.app_context(): self.start_services() setup(self)
music_folder = os.path.expanduser('~/Music') conn = None def start_app(sender, **extra): global conn conn = sqlite3.connect(os.path.expanduser('~/.config/beets/library.db')) def stop_app(sender, **extra): global conn conn.close() appcontext_pushed.connect(start_app, app) appcontext_tearing_down.connect(stop_app, app) @app.route('/') def index(): return 'Welcome to Beet-Sync!' @app.route('/albums') def albums(): cursor = conn.cursor() cursor.execute( 'SELECT album,albumartist FROM albums ORDER BY albumartist;') ret_obj = [] for row in cursor:
''' Initialize additions to the flask 'g' variable. ''' from flask import g, appcontext_pushed from sandhill import app def g_set(_): """ Make instance_path available for global use. """ g.instance_path = app.instance_path # pylint: disable=assigning-non-slot appcontext_pushed.connect(g_set, app)
def setup(self, config: Optional[type]) -> None: self.configure(config) # At this point we have loaded all external config files: # SQLALCHEMY_DATABASE_URI is definitively fixed (it cannot be defined in # database AFAICT), and LOGGING_FILE cannot be set in DB settings. self.setup_logging() appcontext_pushed.connect(self.install_id_generator) if not self.testing: self.init_sentry() # time to load config bits from database: 'settings' # First init required stuff: db to make queries, and settings service extensions.db.init_app(self) settings_service.init_app(self) self.register_jinja_loaders(jinja2.PackageLoader("abilian.web")) self.init_assets() self.install_default_handlers() with self.app_context(): self.init_extensions() self.register_plugins() self.add_access_controller("static", allow_access_for_roles(Anonymous), endpoint=True) # debugtoolbar: this is needed to have it when not authenticated # on a private site. We cannot do this in init_debug_toolbar, # since auth service is not yet installed. self.add_access_controller("debugtoolbar", allow_access_for_roles(Anonymous)) self.add_access_controller( "_debug_toolbar.static", allow_access_for_roles(Anonymous), endpoint=True, ) # TODO: maybe reenable later # self.maybe_register_setup_wizard() self._finalize_assets_setup() # At this point all models should have been imported: time to configure # mappers. Normally Sqlalchemy does it when needed but mappers may be # configured inside sa.orm.class_mapper() which hides a # misconfiguration: if a mapper is misconfigured its exception is # swallowed by class_mapper(model) results in this laconic # (and misleading) message: "model is not mapped" sa.orm.configure_mappers() signals.components_registered.send(self) request_started.connect(self.setup_nav_and_breadcrumbs) init_hooks(self) # Initialize Abilian core services. # Must come after all entity classes have been declared. # Inherited from ServiceManager. Will need some configuration love # later. if not self.testing: with self.app_context(): self.start_services() setup(self)