def test(self): container = containers.DynamicContainer() container.from_schema( { 'version': '1', 'container': { 'provider1': { 'provider': 'Factory', 'provides': 'list', 'args': [1, 2, 3], }, 'provider2': { 'provider': 'Factory', 'provides': 'dict', 'kwargs': { 'one': 'container.provider1', 'two': 2, }, }, }, }, ) self.assertIsInstance(container.provider1, providers.Factory) self.assertIs(container.provider1.provides, list) self.assertEqual(container.provider1.args, (1, 2, 3)) self.assertIsInstance(container.provider2, providers.Factory) self.assertIs(container.provider2.provides, dict) self.assertEqual(container.provider2.kwargs, { 'one': container.provider1, 'two': 2 })
def test(self): container = containers.DynamicContainer() container.from_yaml_schema(f'{_SAMPLES_DIR}/schemasample/container-multiple.yml') container.core.config.from_dict({ 'database': { 'dsn': ':memory:', }, 'aws': { 'access_key_id': 'KEY', 'secret_access_key': 'SECRET', }, 'auth': { 'token_ttl': 3600, }, }) # User service user_service1 = container.services.user() user_service2 = container.services.user() self.assertIsInstance(user_service1, UserService) self.assertIsInstance(user_service2, UserService) self.assertIsNot(user_service1, user_service2) self.assertIsInstance(user_service1.db, sqlite3.Connection) self.assertIsInstance(user_service2.db, sqlite3.Connection) self.assertIs(user_service1.db, user_service2.db) # Auth service auth_service1 = container.services.auth() auth_service2 = container.services.auth() self.assertIsInstance(auth_service1, AuthService) self.assertIsInstance(auth_service2, AuthService) self.assertIsNot(auth_service1, auth_service2) self.assertIsInstance(auth_service1.db, sqlite3.Connection) self.assertIsInstance(auth_service2.db, sqlite3.Connection) self.assertIs(auth_service1.db, auth_service2.db) self.assertIs(auth_service1.db, container.gateways.database_client()) self.assertIs(auth_service2.db, container.gateways.database_client()) self.assertEqual(auth_service1.token_ttl, 3600) self.assertEqual(auth_service2.token_ttl, 3600) # Photo service photo_service1 = container.services.photo() photo_service2 = container.services.photo() self.assertIsInstance(photo_service1, PhotoService) self.assertIsInstance(photo_service2, PhotoService) self.assertIsNot(photo_service1, photo_service2) self.assertIsInstance(photo_service1.db, sqlite3.Connection) self.assertIsInstance(photo_service2.db, sqlite3.Connection) self.assertIs(photo_service1.db, photo_service2.db) self.assertIs(photo_service1.db, container.gateways.database_client()) self.assertIs(photo_service2.db, container.gateways.database_client()) self.assertIs(photo_service1.s3, photo_service2.s3) self.assertIs(photo_service1.s3, container.gateways.s3_client()) self.assertIs(photo_service2.s3, container.gateways.s3_client())
def test_wire(self): sub = containers.DynamicContainer() sub.int_object = providers.Object(1) container = containers.DynamicContainer() container.config = providers.Configuration() container.service = providers.Factory(Service) container.sub = sub container.wire( modules=[module], packages=[package], ) self.addCleanup(container.unwire) service = module.test_function() self.assertIsInstance(service, Service)
def container(): sub = containers.DynamicContainer() sub.int_object = providers.Object(1) container = containers.DynamicContainer() container.config = providers.Configuration() container.service = providers.Factory(Service) container.sub = sub container.wire( modules=[module], packages=[package], ) yield container container.unwire()
class Container(containers.DeclarativeContainer): class Container1(containers.DeclarativeContainer): pass class Container2(containers.DeclarativeContainer): pass Container3 = containers.DynamicContainer()
def test_parent_deepcopy(provider): container = containers.DynamicContainer() container.name = provider copied = providers.deepcopy(container) assert container.name.parent is container assert copied.name.parent is copied assert container is not copied assert container.name is not copied.name assert container.name.parent is not copied.name.parent
def test_parent_deepcopy(self): container = containers.DynamicContainer() provider = providers.Container(TestCore) container.name = provider copied = providers.deepcopy(container) self.assertIs(container.name.parent, container) self.assertIs(copied.name.parent, copied) self.assertIsNot(container, copied) self.assertIsNot(container.name, copied.name) self.assertIsNot(container.name.parent, copied.name.parent)
def test(self): container = containers.DynamicContainer() container.from_yaml_schema(f'{_SAMPLES_DIR}/schemasample/container-boto3-session.yml') container.config.from_dict( { 'aws_access_key_id': 'key', 'aws_secret_access_key': 'secret', 'aws_session_token': 'token', 'aws_region_name': 'us-east-1', }, ) self.assertEqual(container.s3_client().__class__.__name__, 'S3') self.assertEqual(container.sqs_client().__class__.__name__, 'SQS')
class Services(containers.DeclarativeContainer): """IoC container of business service componant providers""" dynamic = containers.DynamicContainer() @staticmethod def add(stype: ServiceType, service, name: str = None, *args, **kwargs): """ registers object or function to Services.dynamic :param name: service name. if None, __name__ will be used """ name = service.__name__ if name is None else name dynamic_provider = stype.value(service, *args, **kwargs) containers.DynamicContainer.__setattr__(Services.dynamic, name, dynamic_provider)
def test_no_yaml_installed(self): @contextlib.contextmanager def no_yaml_module(): containers.yaml = None yield containers.yaml = yaml container = containers.DynamicContainer() with no_yaml_module(): with self.assertRaises(errors.Error) as error: container.from_yaml_schema('./no-yaml-installed.yml') self.assertEqual( error.exception.args[0], 'Unable to load yaml schema - PyYAML is not installed. ' 'Install PyYAML or install Dependency Injector with yaml extras: ' '"pip install dependency-injector[yaml]"', )
def test_with_loader(self): container = containers.DynamicContainer() with tempfile.TemporaryDirectory() as tmp_dir: schema_path = os.path.join(tmp_dir, 'schema.yml') with open(schema_path, 'w') as file: file.write(""" version: "1" container: provider: provider: Factory provides: list args: [1, 2, 3] """) container.from_yaml_schema(schema_path, loader=yaml.Loader) self.assertIsInstance(container.provider, providers.Factory) self.assertIs(container.provider.provides, list) self.assertEqual(container.provider.args, (1, 2, 3))
def test(self): container = containers.DynamicContainer() with tempfile.TemporaryDirectory() as tmp_dir: schema_path = os.path.join(tmp_dir, 'schema.json') with open(schema_path, 'w') as file: file.write( json.dumps( { 'version': '1', 'container': { 'provider1': { 'provider': 'Factory', 'provides': 'list', 'args': [1, 2, 3], }, 'provider2': { 'provider': 'Factory', 'provides': 'dict', 'kwargs': { 'one': 'container.provider1', 'two': 2, }, }, }, }, indent=4, ), ) container.from_json_schema(schema_path) self.assertIsInstance(container.provider1, providers.Factory) self.assertIs(container.provider1.provides, list) self.assertEqual(container.provider1.args, (1, 2, 3)) self.assertIsInstance(container.provider2, providers.Factory) self.assertIs(container.provider2.provides, dict) self.assertEqual(container.provider2.kwargs, { 'one': container.provider1, 'two': 2 })
def test(self): container = containers.DynamicContainer() with tempfile.TemporaryDirectory() as tmp_dir: schema_path = os.path.join(tmp_dir, 'schema.yml') with open(schema_path, 'w') as file: file.write(""" version: "1" container: provider1: provider: Factory provides: list args: - 1 - 2 - 3 provider2: provider: Factory provides: dict kwargs: one: container.provider1 two: 2 """) container.from_yaml_schema(schema_path) self.assertIsInstance(container.provider1, providers.Factory) self.assertIs(container.provider1.provides, list) self.assertEqual(container.provider1.args, (1, 2, 3)) self.assertIsInstance(container.provider2, providers.Factory) self.assertIs(container.provider2.provides, dict) self.assertEqual(container.provider2.kwargs, { 'one': container.provider1, 'two': 2 })
import dependency_injector.containers as containers import dependency_injector.providers as providers import dependency_injector.errors as errors class SequenceProvider(providers.Factory): """Sequence factory. Can provide only sequence objects. """ provided_type = collections.Sequence sequences_container = containers.DynamicContainer() sequences_container.provider_type = SequenceProvider if __name__ == '__main__': try: sequences_container.object_provider = providers.Factory(object) except errors.Error as exception: print exception # <dependency_injector.containers.DynamicContainer object at # 0x107820ed0> can contain only <class '__main__.SequenceProvider'> # instances try: sequences_container.object_provider = SequenceProvider(object) except errors.Error as exception:
if not dc: return None try: return getattr(DataTypeContainer, dc["class"])().from_dict(dc) except KeyError: return None def _apply_transformations(self, value: Any): result = value for f in self.transformations: result = f(result) return result def __getstate__(self) -> dict: return {"class": str(self)} def __setstate__(self, new_state: dict): pass def __reduce__(self): return (DataType, (), self.__getstate__()) def __str__(self) -> str: return type(self).__name__ DataTypeContainer = containers.DynamicContainer()
... def populate_container(container, providers_config): for provider_name, provider_info in providers_config.items(): provided_cls = globals().get(provider_info['class']) provider_cls = getattr(providers, provider_info['provider_class']) setattr(container, provider_name, provider_cls(provided_cls)) if __name__ == '__main__': services_config = { 'user': { 'class': 'UserService', 'provider_class': 'Factory', }, 'auth': { 'class': 'AuthService', 'provider_class': 'Factory', }, } services = containers.DynamicContainer() populate_container(services, services_config) user_service = services.user() auth_service = services.auth() assert isinstance(user_service, UserService) assert isinstance(auth_service, AuthService)
def test_parent_name(self): container = containers.DynamicContainer() provider = providers.DependenciesContainer() container.name = provider self.assertEqual(provider.parent_name, 'name')
category_name ) image_full_path = os.path.join(dataset_dir, image_filename) x.append( self.get_x_type().convert_to_expected_format(image_full_path) ) y.append(category_data) except Exception as err: print(err) else: raise ValueError(f"Invalid organization value: {self.get_organization()}") dataset.x = np.array(x) dataset.y = np.array(y) return dataset DatasetIORegistry = containers.DynamicContainer() setattr(DatasetIORegistry, NpzDatasetIO.Label, providers.Factory(NpzDatasetIO)) setattr(DatasetIORegistry, TxtDatasetIO.Label, providers.Factory(TxtDatasetIO)) setattr( DatasetIORegistry, CategoricalImgDatasetIO.Label, providers.Factory(CategoricalImgDatasetIO), )
def test_dynamic(self): container: containers.Container = containers.DynamicContainer() self.assertIsInstance(container, containers.Container)
def test_parent_name(self): container = containers.DynamicContainer() provider = providers.Container(TestCore) container.name = provider self.assertEqual(provider.parent_name, 'name')
def container(): return containers.DynamicContainer()
def __init__(self, config, main, common_ioc_factory, message_bus_ioc_factory, combinator_ioc_factory, lexicomb_ioc_factory, state_machine_ioc_factory, lexical_state_machine_ioc_factory, interpreter_state_machine_ioc_factory): self.__instance = containers.DynamicContainer() logging_provider = IocUtil.create_basic_log_adapter(providers, "bbpyp.lexicomb_engine") common_ioc = common_ioc_factory(config=config, source_format_rules={ ":=": {"format": [(r"\s*{}\s*", r"{} ")]}, "+": {"format": [(r"\s*{}\s*", r" {} ")]}, "-": {"format": [(r"\s*{}\s*", r" {} ")]}, "*": {"format": [(r"\s*{}\s*", r" {} ")]}, "/": {"format": [(r"\s*{}\s*", r" {} ")]}, ";": {"format": [(r"\s*{}\s*", r"{}" + linesep)]}, "{": {"format": [(r"\s*{}\s*", r"{}" + linesep)], "indent_delta": IndentDelta.INCREASE}, "}": {"format": [(rf"\s*{linesep}{{{{1}}}}(\s*){{}}\s*", linesep + r"\1{}" + linesep)], "indent_delta": IndentDelta.DECREASE}, "return": {"format": [(rf"\s*{linesep}{{{{1}}}}(\s*){{}}\s*", linesep + r"\1{} ")]} }).build() message_bus_ioc = message_bus_ioc_factory( config=config, common_ioc=common_ioc).build() combinator_ioc = combinator_ioc_factory( common_ioc=common_ioc).build() lexicomb_ioc = lexicomb_ioc_factory( config=config, common_ioc=common_ioc, combinator_ioc=combinator_ioc).build() state_machine_ioc = state_machine_ioc_factory() lexical_state_machine_ioc = lexical_state_machine_ioc_factory( config=config, common_ioc=common_ioc, state_machine_ioc=state_machine_ioc).build() interpreter_state_machine_ioc = interpreter_state_machine_ioc_factory( config=config, common_ioc=common_ioc, state_machine_ioc=state_machine_ioc).build() lexical_actions_provider = providers.Singleton( LexicalActions, logger=logging_provider, lexer=lexicomb_ioc.lexer_provider, queue_service=common_ioc.queue_service_provider, notification_service=common_ioc.notification_service_provider) interpreter_actions_provider = providers.Singleton( InterpreterActions, logger=logging_provider, parser_combinator=lexicomb_ioc.parser_provider, queue_service=common_ioc.queue_service_provider, notification_service=common_ioc.notification_service_provider) lexical_state_machine_ioc.lexical_actions_provider.provided_by( lexical_actions_provider) interpreter_state_machine_ioc.interpreter_actions_provider.provided_by( interpreter_actions_provider) lexicomb_pub_sub_client_provider = providers.DelegatedFactory( LexicombPubSubClient, logger=logging_provider, queue_service=common_ioc.queue_service_provider, notification_service=common_ioc.notification_service_provider, message_factory=message_bus_ioc.message_factory_provider, file_stream_service=common_ioc.file_stream_service_provider, context_service=common_ioc.context_service_provider, async_service=common_ioc.async_service_provider) create_client = providers.DelegatedCallable( self.__create_lexicomb_client, logger=logging_provider, pub_sub=message_bus_ioc.pub_sub_provider, message_pipe_line_builder=message_bus_ioc.message_pipe_line_builder_provider, pub_sub_client_factory=lexicomb_pub_sub_client_provider, lexical_state_machine=lexical_state_machine_ioc.lexical_state_machine_provider, interpreter_state_machine=interpreter_state_machine_ioc.interpreter_state_machine_provider) self.__instance.lexicomb_ioc = lexicomb_ioc self.__instance.main = providers.Callable( main, create_client=create_client, pub_sub=message_bus_ioc.pub_sub_provider, async_service=common_ioc.async_service_provider, metric_service=common_ioc.metric_service_provider)
# Core import os from jinja2 import Environment, FileSystemLoader # Dependency injector from dependency_injector import containers from dependency_injector import providers app = None db = None bcrypt = None jinja = Environment(loader=FileSystemLoader( os.path.join(os.path.dirname(__file__), 'templates'))) # User context user_context = containers.DynamicContainer() def init_user_app( app_instance, db_instance, bcrypt_instance, ): global app global db global bcrypt app = app_instance db = db_instance bcrypt = bcrypt_instance
class Kernel: """The application initializer. It loads all the components and then let the control to the bundles""" inject_bindings = {} config = None container = containers.DynamicContainer() def load_configuration(self, configuration_file, parameters_file): """Parse the configuration and put it into the kernel and container""" self.console.log("Parsing configuration...") try: self.config = load_configuration( configuration_file_path=configuration_file, parameters_file_path=parameters_file, bundles=self.bundles ) Kernel.config = self.config self.container.configuration = Configuration() self.console.log("Configuration [bold green]OK[/]") except ValidationError as ex: self.console.rule("[bold red]Configuration error") for error in ex.errors(): loc = "[yellow] -> [/]".join([f"[cyan]{i}[/]" for i in error["loc"]]) self.console.print(f"{loc}: {error['msg']} (type={error['type']})") sys.exit() def kernel_ready_event(self, _event): """Seeing this message is the proof that the events are working""" table = Table(show_header=False, style="bold green") table.add_row("Kernel ready") self.console.print(table) def kernel_shutdown_event(self, _event): """Seeing this message is the proof that the events are working""" table = Table(show_header=False, style="bold cyan") table.add_row("Kernel shutdown") self.console.print(table) def register_event_listeners(self): """Add all kernel and bundles listeners""" self.console.log("Registering event listeners") self.event_manager.add_listener(event=KernelReadyEvent, listener=self.kernel_ready_event) self.event_manager.add_listener(event=KernelShutdownEvent, listener=self.kernel_shutdown_event) for bundle in self.bundles: if hasattr(bundle, 'event_listeners'): for event_type, listener in bundle.event_listeners: self.event_manager.add_listener(event=event_type, listener=listener) event_list = ', '.join( [f'[bright_magenta]{event_type.__name__}[/]' for event_type, _ in bundle.event_listeners] ) self.console.log(f"Registered events for [bold cyan]{bundle.__class__.__name__}[/]: {event_list}") self.console.log("Events [bold green]OK[/]") def build_dependency_container(self): """Build the kernel and bundles service containers""" self.console.log("Building dependency container") for bundle in self.bundles: if hasattr(bundle, 'injection_bindings'): for class_type, provider in bundle.injection_bindings.items(): setattr(self.container, class_type, provider) self.console.log("Dependency container built") def register_services(self): """Register the bundles services but not run them yet, it will be done later""" self.console.log("Registering services") for bundle in self.bundles: if hasattr(bundle, 'services'): for service_name, service_function, args, kwargs in bundle.services: self.console.log(f"Adding {service_name}") self.service_runner.add_service( name=service_name, function=service_function, args=args, kwargs=kwargs ) def __init__(self, environment, bundles, configuration_file="config/config.yml", parameters_file="config/parameters.yml"): self.console = Console() self.console.log(f"Running environment [bold green]{environment}[/]") self.bundles = bundles self.environment = environment self.event_manager = EventManager() self.service_runner = ProcessServiceRunner() self.shutting_down = False # Signals signal.signal(signal.SIGINT, self._signal_handler) signal.signal(signal.SIGTERM, self._signal_handler) with self.console.status("[bold green]Booting kernel..."): self.load_configuration(configuration_file=configuration_file, parameters_file=parameters_file) self.register_event_listeners() self.event_manager.dispatch(ConfigurationReadyEvent(configuration=self.config)) self.build_dependency_container() self.event_manager.dispatch(KernelReadyEvent()) self.register_services() self.service_runner.run() def _signal_handler(self, _os_signal, _frame): self.shutdown() def shutdown(self): """Start the kernel shutdown process. It will stopp all services and the exit""" if not self.shutting_down: table = Table(show_header=False, style="bold red") table.add_row("Shutdown signal received, press ctrl + c to kill the process") self.console.print(table) self.shutting_down = True self.service_runner.shutdown() else: self.console.log("[bold red]Killing...[/]") self.service_runner.kill() def wait(self): """Wait until all services are done""" self.service_runner.wait() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.event_manager.dispatch(KernelShutdownEvent())
def test_parent_name_is_none(): container = containers.DynamicContainer() assert container.parent_name is None
# -*- coding: utf-8 # Dependency injector from dependency_injector import containers from dependency_injector import providers app = None db = None # Messaging context messaging_context = containers.DynamicContainer() def init_messaging_app( app_instance, db_instance, ): global app global db app = app_instance db = db_instance # Stores from .stores.channel_store import ChannelStore from .stores.message_store import MessageStore # Query sets from .query_sets.channel_query import ChannelQuery from .query_sets.message_query import MessageQuery from .query_sets.channel_user_query import ChannelUserQuery
def test_parent_name_is_none(self): container = containers.DynamicContainer() self.assertIsNone(container.parent_name)
class Kernel: """The application initializer. It loads all the components and then let the control to the bundles""" inject_bindings = {} config = None container = containers.DynamicContainer() def load_configuration(self, configuration_file, parameters_file): """Parse the configuration and put it into the kernel and container""" self.console.log("Parsing configuration...") try: self.config = load_configuration( configuration_file_path=configuration_file, parameters_file_path=parameters_file, bundles=self.bundles) Kernel.config = self.config self.container.configuration = Configuration() self.console.log("Configuration [bold green]OK[/]") except ValidationError as ex: self.console.rule("[bold red]Configuration error") for error in ex.errors(): loc = "[yellow] -> [/]".join( [f"[cyan]{i}[/]" for i in error["loc"]]) self.console.print( f"{loc}: {error['msg']} (type={error['type']})") sys.exit() def kernel_ready_event(self, _event): """Seeing this message is the proof that the events are working""" table = Table(show_header=False, style="bold green") table.add_row("Kernel ready") self.console.print(table) def kernel_shutdown_event(self, _event): """Seeing this message is the proof that the events are working""" table = Table(show_header=False, style="bold cyan") table.add_row("Kernel shutdown") self.console.print(table) def register_event_listeners(self, config_only: bool = False): """Add all kernel and bundles listeners""" config_text = "for ConfigurationReadyEvent only" if config_only else "for all other events" self.console.log(f"Registering event listeners {config_text}") for bundle in self.bundles: event_list = self.register_event_listeners_for_bundle( bundle, config_only=config_only) self.log_event_listeners_registered_for_bundle(bundle, event_list) # Blinker does not duplicate signals so there is probably no reason to worry about adding listeners # twice, but anyways checking makes sense to me. if not config_only: self.event_manager.add_listener(event=KernelReadyEvent, listener=self.kernel_ready_event) self.event_manager.add_listener( event=KernelShutdownEvent, listener=self.kernel_shutdown_event) self.console.log("Events [bold green]OK[/]") def register_event_listeners_for_bundle(self, bundle: object, config_only: bool = False): """Add bundles' event listeners""" registered_listeners = [] for event_type, listener in getattr(bundle, 'event_listeners', []): is_config_event = issubclass(event_type, ConfigurationReadyEvent) must_register = is_config_event if config_only else not is_config_event if not must_register: continue self.event_manager.add_listener(event=event_type, listener=listener) registered_listeners.append(event_type) return registered_listeners def log_event_listeners_registered_for_bundle( self, bundle: object, registered_listeners: List[str]): """Display in the console the added event listeners""" if registered_listeners: event_list = ', '.join([ f'[bright_magenta]{event_type.__name__}[/]' for event_type in registered_listeners ]) self.console.log( f"Registered events for [bold cyan]{bundle.__class__.__name__}[/]: {event_list}" ) def build_dependency_container(self): """Build the kernel and bundles service containers""" self.console.log("Building dependency container") wire_modules = [] for bundle in self.bundles: if hasattr(bundle, 'injection_bindings'): for class_type, provider in bundle.injection_bindings.items(): # A container provider is useful when a container has dependencies on other containers. Just provide # the container class as an easy way to use the defaults if isinstance(provider, types.FunctionType): # We use a function instead of directly the Provider to ensure that the dependencies are using # exactly the same container (and not other instance). Otherwise, the singletons will not be # singletons (will be at least two instances, one per container provider = provider(self.container) else: provider = providers.Container(provider) setattr(self.container, class_type, provider) if hasattr(bundle, 'wire_modules'): wire_modules += bundle.wire_modules # Applauncher services self.container.event_manager = providers.Object(self.event_manager) self.container.kernel = providers.Object(self) if wire_modules: self.console.log(f"[bold cyan]Wiring[/] modules: {wire_modules}") self.container.wire(modules=[ importlib.import_module(module) for module in wire_modules ]) self.console.log("Dependency container [bold]built[/]") def register_services(self): """Register the bundles services but not run them yet, it will be done later""" self.console.log("Registering services") for bundle in self.bundles: if hasattr(bundle, 'services'): for service_name, service_function, args, kwargs in bundle.services: self.console.log(f"Adding {service_name}") self.service_runner.add_service(name=service_name, function=service_function, args=args, kwargs=kwargs) def __init__(self, environment, bundles, configuration_file="config/config.yml", parameters_file="config/parameters.yml"): self.console = Console() self.console.log(f"Running environment [bold green]{environment}[/]") self.bundles = bundles self.environment = environment self.event_manager = EventManager() self.service_runner = ProcessServiceRunner() self.shutting_down = False # Signals signal.signal(signal.SIGINT, self._signal_handler) signal.signal(signal.SIGTERM, self._signal_handler) with self.console.status("[bold green]Booting kernel..."): self.load_configuration(configuration_file=configuration_file, parameters_file=parameters_file) self.register_event_listeners(config_only=True) self.event_manager.dispatch( ConfigurationReadyEvent(configuration=self.config)) self.register_event_listeners() self.build_dependency_container() self.event_manager.dispatch(KernelReadyEvent()) self.register_services() self.service_runner.run() def _signal_handler(self, _os_signal, _frame): self.shutdown() def shutdown(self): """Start the kernel shutdown process. It will stopp all services and the exit""" is_main = current_process().name == 'MainProcess' if not self.shutting_down: if is_main: table = Table(show_header=False, style="bold red") table.add_row( "Shutdown signal received, press ctrl + c to kill the process" ) self.console.print(table) self.shutting_down = True self.service_runner.shutdown() # The container should be shutted down even in forks self.container.shutdown_resources() elif is_main: self.console.log("[bold red]Killing...[/]") self.service_runner.kill() def wait(self): """Wait until all services are done""" self.service_runner.wait() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.event_manager.dispatch(KernelShutdownEvent())
"""Dynamic container simple example.""" import dependency_injector.containers as containers import dependency_injector.providers as providers # Defining dynamic container: container = containers.DynamicContainer() container.factory1 = providers.Factory(object) container.factory2 = providers.Factory(object) # Creating some objects: object1 = container.factory1() object2 = container.factory2() # Making some asserts: assert object1 is not object2 assert isinstance(object1, object) and isinstance(object2, object)
from typing import Dict from dependency_injector import containers, providers # Test 1: to check setattr container1 = containers.DynamicContainer() container1.abc = providers.Provider() # Test 2: to check override() container2 = containers.DynamicContainer() container2.override(containers.DynamicContainer()) # Test 3: to check override_providers() container3 = containers.DynamicContainer() container3.override_providers(a=providers.Provider()) # Test 4: to check set_providers() container4 = containers.DynamicContainer() container4.set_providers(a=providers.Provider()) # Test 5: to check .dependencies attribute container5 = containers.DynamicContainer() dependencies: Dict[str, providers.Provider] = container5.dependencies # Test 6: to check base class container6: containers.Container = containers.DynamicContainer()