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 __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 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 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 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 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 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
