def include(app): conversion_map = { 'authenticator': 'object', 'authorizer': 'object', } defaults = { 'authorizer': None, } required = ('authenticator',) settings = parse_settings( app.settings, conversion_map=conversion_map, defaults=defaults, required=required, prefix='tangled.auth.') app['authenticator'] = settings['authenticator'] app['authenticator.args'] = parse_settings( settings, prefix='authenticator.') app['authorizer'] = settings['authorizer'] app['authorizer.args'] = parse_settings(settings, prefix='authorizer.') if app['authorizer'] and not app['authenticator']: raise ConfigurationError('No authenticator registered') app.settings['tangled.app.handler.auth'] = auth_handler app.add_config_field('*/*', 'requires_authentication', False) app.add_config_field('*/*', 'permission', None) app.add_config_field('*/*', 'not_logged_in', False) app.add_request_attribute(authenticator) app.add_request_attribute(authorizer)
def include(app): conversion_map = { 'url': make_url, 'make_engine': 'object', 'make_session_factory': 'object', 'sessionmaker.class_': 'object', 'sessionmaker.autoflush': 'bool', 'sessionmaker.autocommit': 'bool', 'sessionmaker.expire_on_commit': 'bool', } defaults = { 'make_engine': make_engine, 'make_session_factory': make_session_factory, } settings = parse_settings( app.settings, conversion_map=conversion_map, defaults=defaults, prefix='sqlalchemy.') engine = settings['make_engine'](app, settings) app['sqlalchemy.engine'] = engine session_factory = settings['make_session_factory'](app, settings) app['sqlalchemy.session_factory'] = session_factory def make_db_session(request): return request.app['sqlalchemy.session_factory']() @cached_property def db_session(request): session = request.make_db_session() request.on_finished(close, session) return session def close(app, request, response, session): if response is None or (400 <= response.status_int < 599): session.rollback() log.debug('Session rolled back') else: session.commit() log.debug('Session committed') session.close() log.debug('Session closed') @property @contextlib.contextmanager def managed_db_session(request): session = request.make_db_session() try: yield session except: session.rollback() raise else: session.commit() finally: session.close() app.add_request_attribute(make_db_session) app.add_request_attribute(db_session) app.add_request_attribute(managed_db_session)
def make_app_settings(settings, conversion_map={}, defaults={}, required=(), prefix=None, strip_prefix=True, parse=True, section='app', **extra_settings): """Create a properly initialized application settings dict. In simple cases, you don't need to call this directly--you can just pass a settings file name or a plain dict to :class:`tangled.web.app.Application`, and this will be called for you. If you need to do custom parsing (e.g., if your app has custom settings), you can call this function with a conversion map, defaults, &c. It's a wrapper around :func:`.parse_settings` that adds a bit of extra functionality: - A file name can be passed instead of a settings dict, in which case the settings will be extracted from the specified ``section`` of that file. - Core tangled.web defaults are *always* added because :class:`tangled.web.app.Application` assumes they are always set. - Settings parsing can be disabled by passing ``parse=False``. This only applies to *your* settings, including defaults and extra settings (*core* defaults are always parsed). - Extra settings can be passed as keyword args; they will override all other settings, and they will be parsed (or not) along with other settings. - Required settings are checked for after all the settings are merged. In really special cases you can create a subclass of :class:`.AAppSettings` and then construct your settings dict by hand (eschewing the use of this function). """ app_settings = parse_settings_file( 'tangled.web:defaults.ini', conversion_map=CONVERSION_MAP, meta_settings=False) if isinstance(settings, str): settings = parse_settings_file(settings, section=section) settings.update(extra_settings) if parse: _conversion_map = CONVERSION_MAP.copy() _conversion_map.update(conversion_map) settings = parse_settings( settings, conversion_map=_conversion_map, defaults=defaults, prefix=prefix, strip_prefix=strip_prefix) else: app_settings.update(defaults) app_settings.update(settings) check_required(app_settings, required) return AppSettings(app_settings)
def create_lookup(settings): """Create Mako template lookup after application is created.""" conversion_map = { 'default_filters': 'list', 'directories': as_list_of(abs_path), 'file_system_checks': 'bool', 'imports': 'list', } defaults = { 'default_filters': 'h', 'input_encoding': 'utf-8', 'output_encoding': None, } lookup_args = parse_settings( settings, conversion_map=conversion_map, defaults=defaults, prefix='mako.lookup.') lookup = TemplateLookup(**lookup_args) return lookup
def create_lookup(settings): """Create Mako template lookup after application is created.""" conversion_map = { 'default_filters': 'list', 'directories': as_list_of(abs_path), 'file_system_checks': 'bool', 'imports': 'list', } defaults = { 'default_filters': 'h', 'input_encoding': 'utf-8', 'output_encoding': None, } lookup_args = parse_settings(settings, conversion_map=conversion_map, defaults=defaults, prefix='mako.lookup.') lookup = TemplateLookup(**lookup_args) return lookup
def include(app): conversion_map = { 'auto': 'bool', # TODO: Support datetime and timedelta too? 'cookie_expires': as_first_of('int', 'bool'), } defaults = { 'auto': True, 'cookie_expires': True, 'type': 'file', 'data_dir': os.path.join(os.getcwd(), 'data/session'), } required = ('key', 'secret') settings = parse_settings( app.settings, conversion_map=conversion_map, defaults=defaults, required=required, prefix='beaker.session.') app['session_factory'] = SessionObject app['session_factory.args'] = settings app.add_request_attribute(session) app.add_request_attribute(flash)