def __init__(self, ipaddrs, userid=None, principals=None, proxies=None, get_userid=None, get_principals=None): r = DottedNameResolver() self.get_userid = r.maybe_resolve(get_userid) self.get_principals = r.maybe_resolve(get_principals) self.ipaddrs = make_ip_set(ipaddrs) self.userid = userid if isinstance(principals, basestring): self.principals = aslist(principals) else: self.principals = principals self.proxies = make_ip_set(proxies)
def get_db_session(request, settings=None): if settings is None: settings = request.registry.settings session_path = settings.get('bowab.db_session', DBSession) resolver = DottedNameResolver() db_session = resolver.maybe_resolve(session_path) return db_session
def render(resource): """TALES extension rendering method""" library, resource_name = resource.split(':') resolver = DottedNameResolver() module = resolver.maybe_resolve(library) resource = getattr(module, resource_name) return get_resource_path(resource)
def main(argv=sys.argv, processor=None): logger = logging.getLogger(__name__) if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) settings = setup_database({}, **settings) session = settings['session'] subscription_model = SubscriptionModel(session) tx_model = TransactionModel(session) maximum_retry = int(settings.get( 'billy.transaction.maximum_retry', TransactionModel.DEFAULT_MAXIMUM_RETRY, )) resolver = DottedNameResolver() if processor is None: processor_factory = settings['billy.processor_factory'] processor_factory = resolver.maybe_resolve(processor_factory) processor = processor_factory() # yield all transactions and commit before we process them, so that # we won't double process them. with db_transaction.manager: logger.info('Yielding transaction ...') subscription_model.yield_transactions() with db_transaction.manager: logger.info('Processing transaction ...') tx_model.process_transactions(processor, maximum_retry=maximum_retry) logger.info('Done')
def site_factory(request): """Application site factory On application startup, this factory checks configuration to get application name and load it from the ZODB; if the application can't be found, configuration is scanned to get application factory, create a new one and create a local site manager. """ conn = get_connection(request) root = conn.root() application_key = request.registry.settings.get(PYAMS_APPLICATION_SETTINGS_KEY, PYAMS_APPLICATION_DEFAULT_NAME) application = root.get(application_key) if application is None: factory = request.registry.settings.get(PYAMS_APPLICATION_FACTORY_KEY) if factory: resolver = DottedNameResolver() factory = resolver.maybe_resolve(factory) else: factory = request.registry.queryUtility(ISiteRootFactory, default=BaseSiteRoot) application = root[application_key] = factory() if IPossibleSite.providedBy(application): lsm = LocalSiteManager(application, default_folder=False) application.setSiteManager(lsm) try: # if some components require a valid and complete registry # with all registered utilities, they can subscribe to # INewLocalSiteCreatedEvent event interface set_local_registry(application.getSiteManager()) get_current_registry().notify(NewLocalSiteCreatedEvent(application)) finally: set_local_registry(None) import transaction # pylint: disable=import-outside-toplevel transaction.commit() return application
def start_scheduler(config): reader = config.settings_reader() settings = reader.settings scheduler = reader.read_str('papaye.scheduler') scheduler_keys = (key[17:] for key in settings.keys() if key.startswith('papaye.scheduler.')) if not reader.read_bool('papaye.cache') or scheduler is None: scheduler = DummyScheduler() else: resolver = DottedNameResolver() scheduler_kwargs = {key[17:]: val for key, val in settings.items() if key in scheduler_keys} scheduler = resolver.maybe_resolve(scheduler)(**scheduler_kwargs) scheduler.start() TaskRegistry().register_scheduler(scheduler) def get_scheduler(request): return scheduler config.add_request_method( get_scheduler, 'scheduler', property=True, reify=True )
def get_processor_factory(settings): """Get processor factory from settings and return """ resolver = DottedNameResolver() processor_factory = settings['billy.processor_factory'] processor_factory = resolver.maybe_resolve(processor_factory) return processor_factory
def __new__(cls, namespace, base, *args, **kw): # Dotted name support makes it easy to configure with pyramid_multiauth name_resolver = DottedNameResolver(caller_package()) base = name_resolver.maybe_resolve(base) # Dynamically create a subclass name = 'Namespaced_%s_%s' % (namespace, base.__name__) klass = type(name, (cls, base), {'_namespace_prefix': namespace + '.'}) return super(NamespacedAuthenticationPolicy, klass).__new__(klass)
def add_logging(config, log_key, log_func=None): resolver = DottedNameResolver() if log_func is None: log_func = operator.attrgetter(log_key) log_func = resolver.maybe_resolve(log_func) config.registry[get_key("registered_loggers")][log_key] = log_func config.registry[get_key("order")].append(log_key)
def __init__(self, ipaddrs, userid=None, principals=None, proxies=None, get_userid=None, get_principals=None): r = DottedNameResolver() self.get_userid = r.maybe_resolve(get_userid) self.get_principals = r.maybe_resolve(get_principals) self.ipaddrs = make_ip_set(ipaddrs) self.userid = userid if isinstance(principals, string_types): self.principals = aslist(principals) else: self.principals = principals self.proxies = make_ip_set(proxies)
def init_transistor(self, **kwargs): if kwargs['output'].scheme == 'file' and \ kwargs['output'].netloc == '-': del self.channels['output'] drain = self.init_stream_drain(**kwargs) elif kwargs['output'].scheme.lower() in ZMQ_TRANSPORTS: drain = self.init_zmq_drain(**kwargs) elif kwargs['output'].scheme == 'kafka': del self.channels['output'] drain = self.init_kafka_drain(**kwargs) elif kwargs['output'].scheme == 'sqs': del self.channels['output'] drain = self.init_sqs_drain(**kwargs) else: raise ValueError( 'Unsupported drain scheme: {}'.format(kwargs['output'].scheme) ) # The gate "has" a drain; # a source "has" a gate resolver = DottedNameResolver() transducer = resolver.maybe_resolve(kwargs['transducer']) if kwargs['transducer_config']: transducer = transducer(*kwargs['transducer_config']) kwargs['gate'] = Gate( self.logger, self.loop, drain, transducer, ) if not kwargs['input'][0].scheme and kwargs['input'][0].path == '-': del self.channels['input'] source = self.init_stream_source(**kwargs) elif kwargs['input'][0].scheme == 'file': del self.channels['input'] source = self.init_pailfile_source(**kwargs) elif kwargs['input'][0].scheme.lower() in ZMQ_TRANSPORTS: source = self.init_zmq_source(**kwargs) elif kwargs['input'][0].scheme == 'kafka': del self.channels['input'] source = self.init_kafka_source(**kwargs) elif kwargs['input'][0].scheme == 'sqs': del self.channels['input'] source = self.init_sqs_source(**kwargs) else: raise ValueError( 'Unsupported source scheme: {}'.format(kwargs['input'].scheme) ) return Transistor( self.logger, self.loop, kwargs['gate'], source, drain, )
def deserialize(self, node, cstruct): if callable(cstruct): return cstruct elif isinstance(cstruct, str): resolver = DottedNameResolver() scheduler = resolver.maybe_resolve(cstruct) return scheduler raise Invalid(node, '{} is not a valid Python dotted name'.format( cstruct ))
def processor(self): """The payment processor """ settings = self.registry.settings resolver = DottedNameResolver() processor_factory = settings['billy.processor_factory'] processor_factory = resolver.maybe_resolve(processor_factory) processor = processor_factory() return processor
def get_api_class(registry): """Looks up a the API class to use within a Pyramid configuration registry. It will return the TemplateAPI class if none is found. """ api_class = TemplateAPI if hasattr(registry, 'settings'): api_class_path = registry.settings.get('bowab.api_class', api_class) resolver = DottedNameResolver() api_class = resolver.maybe_resolve(api_class_path) return api_class
def list_view(session, model, columns, **kw): """ create list_view imperatively :param session: session object or dotted_name. :param model: model class or dotted_name. :param columns: column definitions for :class:`rebecca.helpers.Grid` :param kw: additional args for :class:`rebecca.helpers.Grid` """ resolver = DottedNameResolver(caller_package()) session = resolver.maybe_resolve(session) model = resolver.maybe_resolve(model) grid = h.Grid(columns, **kw) View = type(model.__name__ + '_ListView', (ListView,), {}) View.session = session View.model = model View.grid = grid return View
def init_transistor(self, **kwargs): if kwargs['output'].scheme == 'file' and \ kwargs['output'].netloc == '-': del self.channels['output'] drain = self.init_stream_drain(**kwargs) elif kwargs['output'].scheme.lower() in ZMQ_TRANSPORTS: drain = self.init_zmq_drain(**kwargs) elif kwargs['output'].scheme == 'kafka': del self.channels['output'] drain = self.init_kafka_drain(**kwargs) elif kwargs['output'].scheme == 'sqs': del self.channels['output'] drain = self.init_sqs_drain(**kwargs) else: raise ValueError('Unsupported drain scheme: {}'.format( kwargs['output'].scheme)) # The gate "has" a drain; # a source "has" a gate resolver = DottedNameResolver() transducer = resolver.maybe_resolve(kwargs['transducer']) if kwargs['transducer_config']: transducer = transducer(*kwargs['transducer_config']) kwargs['gate'] = Gate( self.logger, self.loop, drain, transducer, ) if not kwargs['input'][0].scheme and kwargs['input'][0].path == '-': del self.channels['input'] source = self.init_stream_source(**kwargs) elif kwargs['input'][0].scheme == 'file': del self.channels['input'] source = self.init_pailfile_source(**kwargs) elif kwargs['input'][0].scheme.lower() in ZMQ_TRANSPORTS: source = self.init_zmq_source(**kwargs) elif kwargs['input'][0].scheme == 'kafka': del self.channels['input'] source = self.init_kafka_source(**kwargs) elif kwargs['input'][0].scheme == 'sqs': del self.channels['input'] source = self.init_sqs_source(**kwargs) else: raise ValueError('Unsupported source scheme: {}'.format( kwargs['input'].scheme)) return Transistor( self.logger, self.loop, kwargs['gate'], source, drain, )
def scan_models(module): """ Scan a models module to force Model registration. Argument `module` can be a models module or a Python dotted string. """ resolver = DottedNameResolver() module = resolver.maybe_resolve(module) scanner = venusian.Scanner() scanner.scan(module)
def get_pwreset_class(registry): """Looks up the password reset class to use within a Pyramid configuration registry. It will return the PasswordReset class if none is set. """ pwreset_class = PasswordReset if hasattr(registry, 'settings'): pwreset_class_path = registry.settings.get( 'speak_friend.pwreset_class', pwreset_class) resolver = DottedNameResolver() pwreset_class = resolver.maybe_resolve(pwreset_class_path) return pwreset_class
def configure(cls, settings: EnvironSettings): kwargs = super(SQLAccessBackend, cls).configure(settings) settings.read_prefix_from_environ("auth.db.") engine_opts = {} poolclass = settings.pop("auth.db.poolclass", None) if poolclass is not None: resolver = DottedNameResolver(__name__) engine_opts["poolclass"] = resolver.maybe_resolve(poolclass) engine = engine_from_config(settings, prefix="auth.db.", **engine_opts) kwargs["dbmaker"] = sessionmaker(bind=engine) # Create SQL schema if not exists Base.metadata.create_all(bind=engine) return kwargs
def debug(self, debugger): local = self.repo.local # noqa remote = self.repo.remote # noqa resolve = DottedNameResolver() debugger_obj = resolve.maybe_resolve(debugger) set_trace = getattr(debugger_obj, 'set_trace', None) if not callable(set_trace): print('Invalid debugger: {}: using pdb'.format(debugger)) import pdb set_trace = pdb.set_trace set_trace() # DEBUGGING pass
def create_spec(registry, zone=None, merge=None): title = registry.settings.get("openapi.title", "Untitled") version = registry.settings.get("openapi.version", "0.0.0") name_resolver = DottedNameResolver() MarshmallowPlugin = name_resolver.maybe_resolve( registry.settings.get("openapi.plugin", "apispec.ext.marshmallow.MarshmallowPlugin")) marshmallow_plugin = MarshmallowPlugin( schema_name_resolver=schema_name_resolver) spec = APISpec( title=title, version=version, openapi_version="3.0.2", plugins=[marshmallow_plugin], ) for path, operations in list_paths(registry.introspector): final_ops = dict() for method, view in operations.items(): if zone is not None and zone != view.get("api_zone"): continue summary, descr, user_op = split_docstring(view["callable"].__doc__) op = { "responses": dict(), "parameters": [], } if summary: op["summary"] = summary if descr: op["description"] = descr set_url_params(spec, op, view) if "validate" in view: if method == "get": set_query_params(spec, op, view) else: set_request_body(spec, op, view) if "marshal" in view: set_response_body(spec, op, view) set_tag(spec, op, view) final_op = utils.deepupdate(op, user_op) final_op = utils.deepupdate(final_op, view.get("api_spec", dict())) # We are required to have some response, so make one up. if not final_op["responses"]: final_op["responses"]["200"] = { "description": "", } final_ops[method] = final_op spec.path(path, operations=final_ops) json = spec.to_dict() return _perform_merges(json, merge, registry.settings.get("openapi.merge"))
def configure(cls, settings: EnvironSettings): kwargs = super(SQLCache, cls).configure(settings) graceful_reload = asbool(settings.pop("db.graceful_reload", False)) settings.read_prefix_from_environ("db.") engine_opts = {} poolclass = settings.pop("db.poolclass", None) if poolclass is not None: resolver = DottedNameResolver(__name__) engine_opts["poolclass"] = resolver.maybe_resolve(poolclass) engine = engine_from_config(settings, prefix="db.", **engine_opts) # Create SQL schema if not exists create_schema(engine) kwargs["dbmaker"] = sessionmaker(bind=engine) kwargs["graceful_reload"] = graceful_reload return kwargs
def includeme(config): """ Configure the app """ settings = config.get_settings() resolver = DottedNameResolver(__name__) dotted_name = getdefaults(settings, "pypi.auth", "pypi.access_backend", "config") if dotted_name == "config": dotted_name = ConfigAccessBackend elif dotted_name == "remote": dotted_name = RemoteAccessBackend elif dotted_name == "sql": dotted_name = SQLAccessBackend access_backend = resolver.maybe_resolve(dotted_name) kwargs = access_backend.configure(settings) config.add_request_method(partial(access_backend, **kwargs), name="access", reify=True)
def includeme(config): """ Configure the app """ settings = config.get_settings() resolver = DottedNameResolver(__name__) dotted_name = settings.get('pypi.access_backend', 'config') if dotted_name == 'config': dotted_name = ConfigAccessBackend elif dotted_name == 'remote': dotted_name = RemoteAccessBackend elif dotted_name == 'sql': dotted_name = 'pypicloud.access.sql.SQLAccessBackend' access_backend = resolver.maybe_resolve(dotted_name) access_backend.configure(settings) config.add_request_method(access_backend, name='access', reify=True)
def start_scheduler(config): settings = config.registry.settings if settings.get('papaye.cache').lower() != 'true' or settings.get('papaye.scheduler') is None: scheduler = DummyScheduler() else: resolver = DottedNameResolver() scheduler_kwargs = {key[17:]: value for key, value in config.registry.settings.items() if key.startswith('papaye.scheduler.')} scheduler = resolver.maybe_resolve(config.registry.settings.get('papaye.scheduler'))(**scheduler_kwargs) scheduler.start() TaskRegistry().register_scheduler(scheduler) def get_scheduler(request): return scheduler config.add_request_method(get_scheduler, 'scheduler', property=True, reify=True)
def includeme(config): """ Configure the app """ settings = config.get_settings() resolver = DottedNameResolver(__name__) dotted_name = getdefaults(settings, 'pypi.auth', 'pypi.access_backend', 'config') if dotted_name == 'config': dotted_name = ConfigAccessBackend elif dotted_name == 'remote': dotted_name = RemoteAccessBackend elif dotted_name == 'sql': dotted_name = SQLAccessBackend access_backend = resolver.maybe_resolve(dotted_name) kwargs = access_backend.configure(settings) config.add_request_method(partial(access_backend, **kwargs), name='access', reify=True)
def ResolveName(name, base=None, raiseExcp=True): """ Lookup python object by dotted python name. Wraps pyramid.DottedNameResolver. returns object or None """ if not name: return None if not isinstance(name, basestring): return name if not base: base = caller_package() if not raiseExcp: d = DottedNameResolver(base) return d.maybe_resolve(name) d = DottedNameResolver(base) return d.resolve(name)
def includeme(config): """ Configure the app """ settings = config.get_settings() resolver = DottedNameResolver(__name__) dotted_name = settings.get('pypi.auth', 'config') if dotted_name == 'config': dotted_name = ConfigAccessBackend elif dotted_name == 'remote': dotted_name = RemoteAccessBackend elif dotted_name == 'sql': dotted_name = SQLAccessBackend elif dotted_name == 'ldap': dotted_name = "pypicloud.access.ldap_.LDAPAccessBackend" access_backend = resolver.maybe_resolve(dotted_name) kwargs = access_backend.configure(settings) config.add_request_method(partial(access_backend, **kwargs), name='access', reify=True) config.add_postfork_hook(partial(access_backend.postfork, **kwargs))
def scan(config, module): r = DottedNameResolver() module = r.maybe_resolve(module) module = inspect.getmodule(module) model_mappings = { models.UserMixin: IUserClass, models.ActivationMixin: IActivationClass, } for name, obj in inspect.getmembers(module): if inspect.isclass(obj): # don't register the horus mixins if obj.__module__ == 'horus.models': continue for mixin, interface in model_mappings.items(): if isinstance(obj, type) and issubclass(obj, mixin): config.registry.registerUtility(obj, interface)
def includeme(config): """ Configure the app """ settings = config.get_settings() resolver = DottedNameResolver(__name__) dotted_name = getdefaults(settings, 'pypi.auth', 'pypi.access_backend', 'config') if dotted_name == 'config': dotted_name = ConfigAccessBackend elif dotted_name == 'remote': dotted_name = RemoteAccessBackend elif dotted_name == 'sql': dotted_name = SQLAccessBackend elif dotted_name == 'ldap': dotted_name = "pypicloud.access.ldap_.LDAPAccessBackend" access_backend = resolver.maybe_resolve(dotted_name) kwargs = access_backend.configure(settings) config.add_request_method(partial(access_backend, **kwargs), name='access', reify=True)
def add_theme(config, cls): """ A Pyramid config directive to initialiaze and register a theme for use. """ resolved_cls = config.maybe_dotted(cls) settings = config.registry.settings theme = resolved_cls(settings) # Call includes package = inspect.getmodule(resolved_cls) resolver = DottedNameResolver(package=package) for include in theme.stacked_includes: config.include(resolver.maybe_resolve(include)) # Register static dirs. static_dirs = settings.setdefault('pyramid_frontend.static_registry', set()) for key, dir in theme.keyed_static_dirs: if (key, dir) not in static_dirs: static_dirs.add((key, dir)) config.add_static_view('_%s' % key, path=dir) # Update global image filter registry as well, and ensure there are no # conflicts. for chain in theme.stacked_image_filters: config.add_image_filter(chain, with_theme=theme) def register(theme): themes = settings.setdefault('pyramid_frontend.theme_registry', {}) themes[theme.key] = theme intr = config.introspectable(category_name='themes', discriminator=theme.key, title=theme.key, type_name=None) intr['theme'] = theme config.action(('theme', theme.key), register, args=(theme,), introspectables=(intr,))
def includeme(config): """ Configure the app """ settings = config.get_settings() resolver = DottedNameResolver(__name__) dotted_name = settings.get("pypi.auth", "config") if dotted_name == "config": dotted_name = ConfigAccessBackend elif dotted_name == "remote": dotted_name = RemoteAccessBackend elif dotted_name == "sql": dotted_name = SQLAccessBackend elif dotted_name == "ldap": dotted_name = "pypicloud.access.ldap_.LDAPAccessBackend" elif dotted_name == "aws_secrets_manager": dotted_name = AWSSecretsManagerAccessBackend access_backend = resolver.maybe_resolve(dotted_name) kwargs = access_backend.configure(settings) config.add_request_method( partial(access_backend, **kwargs), name="access", reify=True ) config.add_postfork_hook(partial(access_backend.postfork, **kwargs))
def includeme(config): """ Configure the app """ settings = config.get_settings() resolver = DottedNameResolver(__name__) dotted_name = settings.get("pypi.auth", "config") if dotted_name == "config": dotted_name = ConfigAccessBackend elif dotted_name == "remote": dotted_name = RemoteAccessBackend elif dotted_name == "sql": dotted_name = SQLAccessBackend elif dotted_name == "ldap": dotted_name = "pypicloud.access.ldap_.LDAPAccessBackend" elif dotted_name == "aws_secrets_manager": dotted_name = AWSSecretsManagerAccessBackend access_backend = resolver.maybe_resolve(dotted_name) kwargs = access_backend.configure(settings) config.add_request_method(partial(access_backend, **kwargs), name="access", reify=True) config.add_postfork_hook(partial(access_backend.postfork, **kwargs))
def __init__(self, arguments): self.client_kwargs = {} resolver = DottedNameResolver() defaults = dict( # Default to behave like pylibmc/python-memcache serializer='pymemcache.serde.python_memcache_serializer', deserializer='pymemcache.serde.python_memcache_deserializer', ) options = { 'import': ('hasher', 'serializer', 'deserializer', 'socket_module', 'lock_generator'), 'bool': ('use_pooling', 'ignore_exc', 'no_delay'), 'int': ('connect_timeout', 'timeout', 'max_pool_size', 'retry_attempts', 'retry_timeout', 'dead_timeout'), 'str': ('key_prefix', ), } for otype, onames in options.items(): for oname in onames: oval = arguments.get(oname, defaults.get(oname)) if oval is None: continue if otype == 'import': self.client_kwargs[oname] = resolver.maybe_resolve(oval) elif otype == 'bool': self.client_kwargs[oname] = asbool(oval) elif otype == 'int': self.client_kwargs[oname] = int(oval) else: self.client_kwargs[oname] = oval super(PyMemcacheBackend, self).__init__(arguments) servers = [] for server in self.url: s_url = server.split(':') servers.append((s_url[0], int(s_url[1]))) self.client_kwargs['servers'] = servers
def __init__(self, arguments): self.client_kwargs = {} resolver = DottedNameResolver() defaults = dict( # Default to behave like pylibmc/python-memcache serializer='pymemcache.serde.python_memcache_serializer', deserializer='pymemcache.serde.python_memcache_deserializer', ) options = { 'import': ('hasher', 'serializer', 'deserializer', 'socket_module', 'lock_generator'), 'bool': ('use_pooling', 'ignore_exc', 'no_delay'), 'int': ('connect_timeout', 'timeout', 'max_pool_size', 'retry_attempts', 'retry_timeout', 'dead_timeout'), 'str': ('key_prefix',), } for otype, onames in options.items(): for oname in onames: oval = arguments.get(oname, defaults.get(oname)) if oval is None: continue if otype == 'import': self.client_kwargs[oname] = resolver.maybe_resolve(oval) elif otype == 'bool': self.client_kwargs[oname] = asbool(oval) elif otype == 'int': self.client_kwargs[oname] = int(oval) else: self.client_kwargs[oname] = oval super(PyMemcacheBackend, self).__init__(arguments) servers = [] for server in self.url: s_url = server.split(':') servers.append((s_url[0], int(s_url[1]))) self.client_kwargs['servers'] = servers
def main(argv=sys.argv, processor=None): logger = logging.getLogger(__name__) if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) settings = setup_database({}, **settings) session = settings['session'] subscription_model = SubscriptionModel(session) tx_model = TransactionModel(session) maximum_retry = int( settings.get( 'billy.transaction.maximum_retry', TransactionModel.DEFAULT_MAXIMUM_RETRY, )) resolver = DottedNameResolver() if processor is None: processor_factory = settings['billy.processor_factory'] processor_factory = resolver.maybe_resolve(processor_factory) processor = processor_factory() # yield all transactions and commit before we process them, so that # we won't double process them. with db_transaction.manager: logger.info('Yielding transaction ...') subscription_model.yield_transactions() with db_transaction.manager: logger.info('Processing transaction ...') tx_model.process_transactions(processor, maximum_retry=maximum_retry) logger.info('Done')
def add_rest_resource(config, cls_or_dotted): """ Add routes and views for a `RestResource` class. """ # Get the resource class definition resolver = DottedNameResolver() cls = resolver.maybe_resolve(cls_or_dotted) resource_name = cls.get_route_prefix() register_resource(cls) # Generate routes and attach views for current class for route_type, route_info in REST_ROUTE_INFO.items(): match_param = "member={}".format(resource_name) # Get action names for current route type and initialize # a route predicate to match the names if 'action' in route_info: action_info_list = cls.get_actions_by_type(route_type) # Attach action methods to current route for action_info in action_info_list: action_name = action_info['name'] request_method = action_info['request_method'] # Init permission for action calls permission_name = action_info.get('permission') if permission_name: permission = permission_name else: permission = cls.model.get_permission('action') # Create a resource action predicate to call the view # only when current action name is called in the URL custom_predicates = (resource_action_predicate(action_name), ) # Add a view also for implicit action call config.add_view( cls, attr=action_info['attr_name'], match_param=match_param, route_name="{}_action".format(route_info['route_name']), decorator=allow_request_methods(request_method), custom_predicates=custom_predicates, renderer='json', request_method=REQUEST_METHODS, permission=permission) # Add views to handle different request methods in this view for request_method in route_info['methods']: # Init the name of the methos that the class should # implement to handle requests for current request method attr_name = '{0}_{1}'.format(request_method.lower(), route_type) view_handler = getattr(cls, attr_name, None) # Skip non callable attributes if not hasattr(view_handler, '__call__'): continue # Init permission name for current handler permission_name = PERMISSION_SUFFIX[request_method] permission = cls.model.get_permission(permission_name) config.add_view( cls, attr=attr_name, match_param=match_param, route_name=route_info['route_name'], renderer='json', request_method=request_method, permission=permission)
def __init__(self, check, *args, **kw): # Dotted name support makes it easy to configure with pyramid_multiauth name_resolver = DottedNameResolver(caller_package()) check = name_resolver.maybe_resolve(check) super(BasicAuthAuthenticationPolicy, self).__init__(check, *args, **kw)
def model(self): # When model is not a class resolve it to be a class resolver = DottedNameResolver() return resolver.maybe_resolve(self._model)
def wrapped(f): resolver = DottedNameResolver() for decorator in decorators: f = resolver.maybe_resolve(decorator)(f) return f