def __init__(self, clients: Dict[str, Dict[str, Any]] = None, **default_client_args) -> None:
"""
If the ``clients`` argument is omitted or empty, a default client with the context
attribute ``wamp`` will be created.
If ``clients`` is defined, any keyword arguments to the component become default options
for the clients.
If you wish to change the context attribute of a WAMP client, use the ``context_attr``
argument.
:param clients: a dictionary of resource name тнв :class:`.WAMPClient` constructor arguments
:param default_client_args: :class:`.WAMPClient` base options for all clients or arguments
for the default client if ``clients`` is not specified
"""
assert check_argument_types()
if not clients:
default_client_args.setdefault('context_attr', 'wamp')
clients = {'default': default_client_args}
self.clients = [] # type: List[Tuple[str, Optional[str], WAMPClient]]
for resource_name, config in clients.items():
config = merge_config(default_client_args, config)
context_attr = config.pop('context_attr', resource_name)
client = WAMPClient(**config)
self.clients.append((resource_name, context_attr, client))
def __init__(self, clients: Dict[str, Dict[str, Any]] = None, **default_client_args):
assert check_argument_types()
if not clients:
default_client_args.setdefault('context_attr', 'mongo')
clients = {'default': default_client_args}
self.clients = []
for resource_name, config in clients.items():
client_args = merge_config(default_client_args, config)
context_attr = client_args.pop('context_attr', resource_name)
self.clients.append((resource_name, context_attr, client_args))
def __init__(self, connections: Dict[str, Dict[str, Any]] = None, **default_client_args):
assert check_argument_types()
if not connections:
default_client_args.setdefault("context_attr", "redis")
connections = {"default": default_client_args}
self.clients = []
for resource_name, config in connections.items():
config = merge_config(default_client_args, config or {})
config.setdefault("context_attr", resource_name)
context_attr, client_args = self.configure_client(**config)
self.clients.append((resource_name, context_attr, client_args))
def __init__(self, gateways: Dict[str, Dict[str, Any]] = None, **default_gateway_args):
assert check_argument_types()
if not gateways:
default_gateway_args.setdefault('context_attr', 'java')
gateways = {'default': default_gateway_args}
self.gateways = []
for resource_name, config in gateways.items():
config = merge_config(default_gateway_args, config)
config.setdefault('context_attr', resource_name)
context_attr, *gateway_settings = self.configure_gateway(**config)
self.gateways.append((resource_name, context_attr) + tuple(gateway_settings))
def __init__(self, clients: Dict[str, Dict[str, Any]] = None, **default_client_args):
assert check_argument_types()
if not clients:
default_client_args.setdefault('context_attr', 'memcached')
clients = {'default': default_client_args}
self.clients = []
for resource_name, config in clients.items():
config = merge_config(default_client_args, config or {})
context_attr = config.pop('context_attr', resource_name)
config.setdefault('host', 'localhost')
client = self.configure_client(**config)
self.clients.append((resource_name, context_attr, client))
def __init__(self,
clients: Dict[str, Dict[str, Any]] = None,
**default_client_args):
assert check_argument_types()
if not clients:
default_client_args.setdefault('context_attr', 'influxdb')
clients = {'default': default_client_args}
self.clients = []
for resource_name, config in clients.items():
client_args = merge_config(default_client_args, config)
context_attr = client_args.pop('context_attr', resource_name)
client = InfluxDBClient(**client_args)
self.clients.append((resource_name, context_attr, client))
def __init__(self, serializers: Dict[str, Optional[Dict[str, Any]]] = None,
**default_serializer_args) -> None:
assert check_argument_types()
if not serializers:
default_serializer_args.setdefault(
'context_attr', default_serializer_args.get('backend'))
serializers = {'default': default_serializer_args}
self.serializers = [] # type: List[Tuple]
for resource_name, config in serializers.items():
merged = merge_config(default_serializer_args, config or {})
type_ = merged.pop('backend', resource_name)
context_attr = merged.pop('context_attr', resource_name)
serializer = serializer_types.create_object(type_, **merged)
self.serializers.append((resource_name, context_attr, serializer))
def __init__(self, components: Dict[str, Dict[str, Any]] = None,
servers: Dict[str, Dict[str, Any]] = None, **default_server_args):
super().__init__(components)
assert check_argument_types()
if not servers:
default_server_args.setdefault('context_attr', 'webserver')
servers = {'default': default_server_args}
self.servers = [] # type: List[Tuple[str, str, BaseWebServer]]
for resource_name, config in servers.items():
config = merge_config(default_server_args, config)
context_attr = config.pop('context_attr', resource_name)
server = server_types.create_object(**config)
self.servers.append((resource_name, context_attr, server))
def __init__(self,
clients: Dict[str, Dict[str, Any]] = None,
**default_client_args):
assert check_argument_types()
if not clients:
default_client_args.setdefault('context_attr', 'memcached')
clients = {'default': default_client_args}
self.clients = []
for resource_name, config in clients.items():
config = merge_config(default_client_args, config or {})
context_attr = config.pop('context_attr', resource_name)
config.setdefault('host', 'localhost')
client = self.configure_client(**config)
self.clients.append((resource_name, context_attr, client))
def __init__(self, serializers: Dict[str, Optional[Dict[str, Any]]] = None,
**default_serializer_args):
assert check_argument_types()
if not serializers:
default_serializer_args.setdefault(
'context_attr', default_serializer_args.get('backend'))
serializers = {'default': default_serializer_args}
self.serializers = []
for resource_name, config in serializers.items():
config = merge_config(default_serializer_args, config or {})
type_ = config.pop('backend', resource_name)
context_attr = config.pop('context_attr', resource_name)
serializer = serializer_types.create_object(type_, **config)
self.serializers.append((resource_name, context_attr, serializer))
def __init__(self,
mailers: Dict[str, Dict[str, Any]] = None,
**default_mailer_args):
assert check_argument_types()
mailers = mailers or {}
if default_mailer_args:
default_mailer_args.setdefault('context_attr', 'mailer')
mailers['default'] = default_mailer_args
self.mailers = [] # type: List[Mailer]
for resource_name, config in mailers.items():
config = merge_config(default_mailer_args, config)
backend = config.pop('backend')
context_attr = config.pop('context_attr', resource_name)
mailer = mailer_backends.create_object(backend, **config)
self.mailers.append((resource_name, context_attr, mailer))
def __init__(self, engines: Dict[str, Dict[str, Any]] = None,
commit_executor: Union[Executor, str] = None, commit_executor_workers: int = 5,
**default_args):
assert check_argument_types()
if not engines:
default_args.setdefault('context_attr', 'sql')
engines = {'default': default_args}
self.session_factories = []
for resource_name, config in engines.items():
config = merge_config(default_args, config)
context_attr = config.pop('context_attr', resource_name)
bind, session_factory, ready_callback = self.configure_engine(**config)
self.session_factories.append(
(resource_name, context_attr, bind, session_factory, ready_callback))
self.commit_executor = commit_executor
self.commit_executor_workers = commit_executor_workers
def __init__(self, feeds: Dict[str, Dict[str, Any]] = None,
stores: Dict[str, Dict[str, Any]] = None, **feed_defaults):
assert check_argument_types()
if not feeds:
feed_defaults.setdefault('context_attr', 'feed')
feeds = {'default': feed_defaults}
self.feeds = []
for resource_name, config in feeds.items():
config = merge_config(feed_defaults, config)
context_attr = config.pop('context_attr', resource_name)
self.feeds.append((resource_name, context_attr, config))
self.stores = []
if stores:
for resource_name, config in stores.items():
store = feed_stores.create_object(**config)
self.stores.append((resource_name, store))
def __init__(self, engines: Dict[str, Dict[str, Any]] = None, session: Dict[str, Any] = True,
**default_engine_args):
assert check_argument_types()
if not engines:
default_engine_args.setdefault('context_attr', 'sql')
engines = {'default': default_engine_args}
self.connectables = []
for resource_name, config in engines.items():
config = merge_config(default_engine_args, config)
config.setdefault('context_attr', resource_name)
context_attr, bind = self.configure_engine(**config)
self.connectables.append((resource_name, context_attr, bind))
if session is not False:
session = {} if session is True else session
if len(self.connectables) == 1:
session.setdefault('bind', self.connectables[0][-1])
self.session_context_attr, self.commit_executor, self.sessionmaker = \
self.configure_sessionmaker(**session)
