def test_call_overridden(self): """Test getting of instances on overridden provider.""" provider = providers.ThreadLocalSingleton(Example) overriding_provider1 = providers.ThreadLocalSingleton(dict) overriding_provider2 = providers.ThreadLocalSingleton(object) provider.override(overriding_provider1) provider.override(overriding_provider2) instance1 = provider() instance2 = provider() self.assertIs(instance1, instance2) self.assertIsInstance(instance1, object) self.assertIsInstance(instance2, object)
def test_repr(self): provider = providers.ThreadLocalSingleton(Example) self.assertEqual( repr(provider), '<dependency_injector.providers.' 'ThreadLocalSingleton({0}) at {1}>'.format(repr(Example), hex(id(provider))))
def test_async_init_with_error(self): # Disable default exception handling to prevent output asyncio.get_event_loop().set_exception_handler( lambda loop, context:...) async def create_instance(): create_instance.counter += 1 raise RuntimeError() create_instance.counter = 0 provider = providers.ThreadLocalSingleton(create_instance) future = provider() self.assertTrue(provider.is_async_mode_enabled()) with self.assertRaises(RuntimeError): self._run(future) self.assertEqual(create_instance.counter, 1) self.assertTrue(provider.is_async_mode_enabled()) with self.assertRaises(RuntimeError): self._run(provider()) self.assertEqual(create_instance.counter, 2) self.assertTrue(provider.is_async_mode_enabled()) # Restore default exception handling asyncio.get_event_loop().set_exception_handler(None)
def test_call_with_context_args(self): """Test getting of instances with context args.""" provider = providers.ThreadLocalSingleton(Example) instance = provider(11, 22) self.assertEqual(instance.init_arg1, 11) self.assertEqual(instance.init_arg2, 22)
def test_repr(self): """Test representation of provider.""" provider = providers.ThreadLocalSingleton(Example) self.assertEqual( repr(provider), '<dependency_injector.providers.creational.' 'ThreadLocalSingleton({0}) at {1}>'.format(repr(Example), hex(id(provider))))
class Gateways(containers.DeclarativeContainer): """IoC container of gateway components.""" _stats_drivers = providers.Object({ "statsd": StatsDDriver, "null": NullDriver }) cache = providers.Singleton(get_cache) lock = providers.Factory(get_lock) redis = providers.Singleton(Redis.from_url, url=(strongr.core.Core.config().redis.url if hasattr(strongr.core.Core.config(),'redis') else '')) sqlalchemy_engine = providers.ThreadLocalSingleton(engine_from_config, configuration=strongr.core.Core.config().db.engine.as_dict(), prefix='') # construct engine from config sqlalchemy_session = providers.ThreadLocalSingleton(sessionmaker(bind=sqlalchemy_engine())) sqlalchemy_base = providers.Singleton(declarative_base) stats = providers.Singleton(_stats_drivers()[strongr.core.Core.config().stats.driver], config=(strongr.core.Core.config().stats.config.as_dict() if hasattr(strongr.core.Core.config().stats, 'config') else {}))
def test_reset_clean(self): provider = providers.ThreadLocalSingleton(Example) instance1 = provider() provider.reset() provider.reset() instance2 = provider() self.assertIsNot(instance1, instance2)
def test_call(self): """Test getting of instances.""" provider = providers.ThreadLocalSingleton(Example) instance1 = provider() instance2 = provider() self.assertIs(instance1, instance2) self.assertIsInstance(instance1, Example) self.assertIsInstance(instance2, Example)
def test_call_with_context_args_and_kwargs(self): """Test getting of instances with context args and kwargs.""" provider = providers.ThreadLocalSingleton(Example, 11) instance = provider(22, init_arg3=33, init_arg4=44) self.assertEqual(instance.init_arg1, 11) self.assertEqual(instance.init_arg2, 22) self.assertEqual(instance.init_arg3, 33) self.assertEqual(instance.init_arg4, 44)
def __init__(self, module_name, connection_string=None, **kwargs): super().__init__() self.connection_string = connection_string self.module_name = 'quactrl.data.' + module_name self.db = get_class('{}.Db'.format(self.module_name))( connection_string, **kwargs) self.Session = providers.ThreadLocalSingleton(self.db.Session) self._load_repos()
def _load_repos(self): for model in self._MODELS: model_name = model.split('.')[1] try: RepoClass = self._get_class(model), except ImportError: RepoClass = self._get_class(model_name) Provider = providers.ThreadLocalSingleton(RepoClass, session=self.Session) setattr(self, model_name + 's', Provider)
class Database(containers.DeclarativeContainer): session = providers.ThreadLocalSingleton( get_tm_session, providers.Singleton( get_session_factory, engine=providers.Factory( engine_from_config, Core.config, prefix='sqlalchemy_')), transaction )
def test_call_with_context_kwargs(self): """Test getting of instances with context kwargs.""" provider = providers.ThreadLocalSingleton(Example, init_arg1=1) instance1 = provider(init_arg2=22) self.assertEqual(instance1.init_arg1, 1) self.assertEqual(instance1.init_arg2, 22) # Instance is created earlier instance1 = provider(init_arg1=11, init_arg2=22) self.assertEqual(instance1.init_arg1, 1) self.assertEqual(instance1.init_arg2, 22)
def test_reset(self): """Test creation and reset of single object.""" provider = providers.ThreadLocalSingleton(object) instance1 = provider() self.assertIsInstance(instance1, object) provider.reset() instance2 = provider() self.assertIsInstance(instance1, object) self.assertIsNot(instance1, instance2)
async def test_concurrent_init(): async def create_instance(): return object() provider = providers.ThreadLocalSingleton(create_instance) future_instance1 = provider() future_instance2 = provider() instance1, instance2 = await asyncio.gather(future_instance1, future_instance2) assert instance1 is instance2
def test_async_mode(self): instance = object() async def create_instance(): return instance provider = providers.ThreadLocalSingleton(create_instance) instance1 = self._run(provider()) instance2 = self._run(provider()) self.assertIs(instance1, instance2) self.assertIs(instance, instance)
async def test_async_mode(): instance = object() async def create_instance(): return instance provider = providers.ThreadLocalSingleton(create_instance) instance1 = await provider() instance2 = await provider() assert instance1 is instance2 assert instance1 is instance assert instance2 is instance
def test_fluent_interface(self): """Test injections definition with fluent interface.""" provider = providers.ThreadLocalSingleton(Example) \ .add_args(1, 2) \ .add_kwargs(init_arg3=3, init_arg4=4) \ .add_attributes(attribute1=5, attribute2=6) instance = provider() self.assertEqual(instance.init_arg1, 1) self.assertEqual(instance.init_arg2, 2) self.assertEqual(instance.init_arg3, 3) self.assertEqual(instance.init_arg4, 4) self.assertEqual(instance.attribute1, 5) self.assertEqual(instance.attribute2, 6)
class Container(containers.DeclarativeContainer): thread_local_object = providers.ThreadLocalSingleton(object) queue_provider = providers.ThreadSafeSingleton(queue.Queue) put_in_queue = providers.Callable( put_in_queue, example_object=thread_local_object, queue_object=queue_provider, ) thread_factory = providers.Factory( threading.Thread, target=put_in_queue.provider, )
def test_call_with_init_positional_args(self): """Test getting of instances with init positional args.""" provider = providers.ThreadLocalSingleton(Example, 'i1', 'i2') instance1 = provider() instance2 = provider() self.assertEqual(instance1.init_arg1, 'i1') self.assertEqual(instance1.init_arg2, 'i2') self.assertEqual(instance2.init_arg1, 'i1') self.assertEqual(instance2.init_arg2, 'i2') self.assertIs(instance1, instance2) self.assertIsInstance(instance1, Example) self.assertIsInstance(instance2, Example)
def test_call_with_attributes(self): """Test getting of instances with attribute injections.""" provider = providers.ThreadLocalSingleton(Example) provider.add_attributes(attribute1='a1', attribute2='a2') instance1 = provider() instance2 = provider() self.assertEqual(instance1.attribute1, 'a1') self.assertEqual(instance1.attribute2, 'a2') self.assertEqual(instance2.attribute1, 'a1') self.assertEqual(instance2.attribute2, 'a2') self.assertIs(instance1, instance2) self.assertIsInstance(instance1, Example) self.assertIsInstance(instance2, Example)
async def test_async_init_with_error(): async def create_instance(): create_instance.counter += 1 raise RuntimeError() create_instance.counter = 0 provider = providers.ThreadLocalSingleton(create_instance) future = provider() assert provider.is_async_mode_enabled() is True with raises(RuntimeError): await future assert create_instance.counter == 1 assert provider.is_async_mode_enabled() is True with raises(RuntimeError): await provider() assert create_instance.counter == 2 assert provider.is_async_mode_enabled() is True
method_caller5: providers.MethodCaller = provider5.provided.method.call( 123, arg=324) # Test 6: to check the DelegatedSingleton provider6 = providers.DelegatedSingleton(Cat) animal6: Animal = provider6(1, 2, 3, b='1', c=2, e=0.0) # Test 7: to check the ThreadSafeSingleton provider7: providers.BaseSingleton[Animal] = providers.ThreadSafeSingleton(Cat) animal7: Animal = provider7() # Test 8: to check the DelegatedThreadSafeSingleton provider8 = providers.DelegatedThreadSafeSingleton(Cat) animal8: Animal = provider8(1, 2, 3, b='1', c=2, e=0.0) # Test 9: to check the ThreadLocalSingleton provider9 = providers.ThreadLocalSingleton(Cat) animal9: Animal = provider9(1, 2, 3, b='1', c=2, e=0.0) # Test 10: to check the DelegatedThreadLocalSingleton provider10 = providers.DelegatedThreadLocalSingleton(Cat) animal10: Animal = provider10(1, 2, 3, b='1', c=2, e=0.0) # Test 11: to check the AbstractSingleton provider11 = providers.AbstractSingleton(Animal) provider11.override(providers.Singleton(Cat)) animal11: Animal = provider11(1, 2, 3, b='1', c=2, e=0.0) # Test 12: to check the SingletonDelegate __init__ provider12 = providers.SingletonDelegate(providers.Singleton(object))
def test_is_provider(self): """Test `is_provider` check.""" self.assertTrue( utils.is_provider(providers.ThreadLocalSingleton(Example)))
def test_init_with_callable(self): """Test creation of provider with a callable.""" self.assertTrue(providers.ThreadLocalSingleton(credits))
"""`ThreadLocalSingleton` providers example.""" import threading import queue import dependency_injector.providers as providers def example(example_object, queue_object): """Put provided object in the provided queue.""" queue_object.put(example_object) # Create thread-local singleton provider for some object (main thread): thread_local_object = providers.ThreadLocalSingleton(object) # Create singleton provider for thread-safe queue: queue_factory = providers.ThreadSafeSingleton(queue.Queue) # Create callable provider for example(), inject dependencies: example = providers.DelegatedCallable( example, example_object=thread_local_object, queue_object=queue_factory, ) # Create factory for threads that are targeted to execute example(): thread_factory = providers.Factory(threading.Thread, target=example) if __name__ == '__main__': # Create 10 threads for concurrent execution of example():
class Container(containers.DeclarativeContainer): service_provider = providers.ThreadLocalSingleton(Service)
class Providers(containers.DeclarativeContainer): interpreters_factory = providers.ThreadLocalSingleton( Interpeters, execution_context=execution_context_builders.Contexts. execution_context, graph=Global.load_rdf('core/data/interpreters.ttl'))