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'))
