def test_repr(self):
provider = providers.DelegatedCallable(_example)
self.assertEqual(
repr(provider), '<dependency_injector.providers.'
'DelegatedCallable({0}) at {1}>'.format(repr(_example),
hex(id(provider))))
def test_call_overridden_by_delegated_callable(self):
def _abstract_example():
pass
provider = providers.AbstractCallable(_abstract_example)
provider.override(providers.DelegatedCallable(_example))
self.assertTrue(provider(1, 2, 3, 4), (1, 2, 3, 4))
def test_call_overridden_by_delegated_callable():
def _abstract_example():
pass
provider = providers.AbstractCallable(_abstract_example)
provider.override(providers.DelegatedCallable(example))
assert provider(1, 2, 3, 4) == (1, 2, 3, 4)
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():
threads = []
for thread_number in range(10):
threads.append(
thread_factory(name='Thread{0}'.format(thread_number)), )
# Start execution of all created threads:
for thread in threads:
def test_inheritance(self):
"""Test inheritance."""
self.assertIsInstance(providers.DelegatedCallable(len),
providers.Callable)
def test_is_delegated_provider(self):
"""Test is_delegated_provider."""
provider = providers.DelegatedCallable(len)
self.assertIs(provider.provide_injection(), provider)
def test_is_provider(self):
"""Test is_provider."""
self.assertTrue(utils.is_provider(providers.DelegatedCallable(len)))
def test_is_delegated_provider(self):
provider = providers.DelegatedCallable(_example)
self.assertTrue(providers.is_delegated(provider))
def test_is_provider(self):
self.assertTrue(
providers.is_provider(providers.DelegatedCallable(_example)))
def test_inheritance(self):
self.assertIsInstance(providers.DelegatedCallable(_example),
providers.Callable)
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)
# Test 4: to check the .args & .kwargs attributes
provider4 = providers.Callable(Animal)
args4: Tuple[Any] = provider4.args
kwargs4: Dict[str, Any] = provider4.kwargs
# Test 5: to check the provided instance interface
provider5 = providers.Callable(Animal)
provided5: providers.ProvidedInstance = provider5.provided
attr_getter5: providers.AttributeGetter = provider5.provided.attr
item_getter5: providers.ItemGetter = provider5.provided['item']
method_caller: providers.MethodCaller = provider5.provided.method.call(123,
arg=324)
# Test 6: to check the DelegatedCallable
provider6 = providers.DelegatedCallable(Cat)
animal6: Animal = provider6(1, 2, 3, b='1', c=2, e=0.0)
# Test 7: to check the AbstractCallable
provider7 = providers.AbstractCallable(Animal)
provider7.override(providers.Callable(Cat))
animal7: Animal = provider7(1, 2, 3, b='1', c=2, e=0.0)
# Test 8: to check the CallableDelegate __init__
provider8 = providers.CallableDelegate(providers.Callable(lambda: None))
# Test 9: to check the return type with await
provider9 = providers.Callable(Cat)
async def _async9() -> None:
def test_inheritance():
assert isinstance(providers.DelegatedCallable(example), providers.Callable)
def test_repr():
provider = providers.DelegatedCallable(example)
assert repr(provider) == ("<dependency_injector.providers."
"DelegatedCallable({0}) at {1}>".format(
repr(example), hex(id(provider))))
def test_is_delegated_provider():
provider = providers.DelegatedCallable(example)
assert providers.is_delegated(provider) is True
def test_is_provider():
assert providers.is_provider(providers.DelegatedCallable(example)) is True
