async def test_isinstance_invalid():
async def get_async():
return {}
provider = providers.Dependency(instance_of=float)
provider.override(providers.Callable(get_async))
assert provider.is_async_mode_undefined() is True
with raises(errors.Error):
await provider()
assert provider.is_async_mode_enabled() is True
async def test_async_mode_enabling_on_overriding():
dependency = object()
async def _get_dependency_async():
return dependency
provider = providers.Provider()
provider.override(providers.Callable(_get_dependency_async))
assert provider.is_async_mode_undefined() is True
await provider()
assert provider.is_async_mode_enabled() is True
class Injector(containers.DeclarativeContainer):
"""
Inyector de dependencias de la aplicacion
"""
env = providers.Configuration()
# components
bioportalApi = providers.Singleton(BioPortalApi, settings=env.bioportal)
mongoDb = providers.Singleton(
MongoDb,
host=env.mongo.host,
database=env.mongo.database,
port=env.mongo.port,
auth=env.mongo.auth,
)
nanopubTest = providers.Callable(negator, env.settings.production)
nanopubClient = providers.Singleton(NanopubClient,
use_test_server=nanopubTest)
# respos
protocolsRepository = providers.Singleton(ProtocolsRepository)
workflows_repository = providers.Singleton(WorkflowsRepository)
nanopubsRepository = providers.Singleton(
NanopublicationRepository, workflows_repository=workflows_repository)
# services
bioportalService = providers.Factory(BioPortalService,
bioportal_api=bioportalApi)
protocolsService = providers.Factory(
ProtocolsService,
protocols_repo=protocolsRepository,
settings=env.settings,
)
statsService = providers.Factory(StatsService,
nanopubs_repo=nanopubsRepository,
settings=env.settings)
workflows_service = providers.Factory(
WorkflowsService,
workflows_repository=workflows_repository,
nanopubs_repository=nanopubsRepository,
settings=env.settings,
nanopub_client=nanopubClient,
)
nanopubsService = providers.Factory(
NanoPubServices,
bioportal_api=bioportalApi,
nanopubs_repo=nanopubsRepository,
protocols_repo=protocolsRepository,
nanopubremote=nanopubClient,
workflows_service=workflows_service,
settings=env.settings,
)
def test_traverse_provides(self):
provider1 = providers.Callable(list)
provider2 = providers.Object('bar')
provider3 = providers.Object('baz')
provider = providers.Singleton(provider1, provider2)
provider.override(provider3)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 3)
self.assertIn(provider1, all_providers)
self.assertIn(provider2, all_providers)
self.assertIn(provider3, all_providers)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
password_hasher = providers.Callable(
passlib.hash.sha256_crypt.hash,
salt_size=config.salt_size,
rounds=config.rounds,
)
user_service = providers.Factory(
UserService,
password_hasher=password_hasher.provider,
)
class Managers(containers.DeclarativeContainer):
config = providers.Configuration()
data_models = providers.DependenciesContainer()
interaction_event_manager = providers.Singleton(
InteractionEventManager, event_types=config.interaction.event_types)
observation_manager = providers.Singleton(ObservationManager)
entity_model_manager = providers.Singleton(EntityModelManager)
entity_fsm_manager = providers.Singleton(EntityFsmManager)
being_model_manager = providers.Singleton(BeingModelManager)
entity_component_manager = providers.Singleton(
EntityComponentManager,
entity_model_manager=entity_model_manager,
entity_fsm_manager=entity_fsm_manager,
being_model_manager=being_model_manager)
turn_manager = providers.Singleton(
TurnManager, entity_model_manager=entity_model_manager)
action_manager = providers.Singleton(ActionManager)
simulation_manager = providers.Singleton(
SimulationStateManager,
grid_model=data_models.grid_model_objective,
entity_component_manager=entity_component_manager,
action_manager=action_manager,
observation_manager=observation_manager,
grid_factory=data_models.grid_model_subjective.provider)
""" Status effect trigger section """
def stub_get_resolver():
raise Exception("This stub needs to be overwritten.")
get_trigger_resolver = providers.Callable(stub_get_resolver)
status_effect_trigger_resolver = providers.Singleton(
StatusEffectTriggerResolver, resolvers_for_type=get_trigger_resolver)
status_effect_manager = providers.Singleton(
StatusEffectManager,
simulation_manager=simulation_manager,
trigger_resolver=status_effect_trigger_resolver)
tick_manager = providers.Singleton(
TickManager,
status_effect_manager=status_effect_manager,
tick_value=config.tick_manager.tick_value,
tick_rate=config.tick_manager.tick_rate)
class IocContainer(containers.DeclarativeContainer):
try:
if len(sys.argv) < 3:
raise Exception(
'O arquivo para carregamento deve ser especificado')
file_route = sys.argv[2]
except:
file_route = 'routes-file.csv'
graphs = providers.Singleton(netx.Graph)
store = providers.Singleton(Store, graphs=graphs, file_routes=file_route)
service = providers.Factory(Service, store=store)
console = providers.Factory(Console, service=service)
console_main = providers.Callable(console().main)
def test_deepcopy_overridden(self):
provider = providers.Callable(_example)
object_provider = providers.Object(object())
provider.override(object_provider)
provider_copy = providers.deepcopy(provider)
object_provider_copy = provider_copy.overridden[0]
self.assertIsNot(provider, provider_copy)
self.assertIs(provider.provides, provider_copy.provides)
self.assertIsInstance(provider, providers.Callable)
self.assertIsNot(object_provider, object_provider_copy)
self.assertIsInstance(object_provider_copy, providers.Object)
def test_deepcopy_overridden():
provider = providers.Callable(example)
object_provider = providers.Object(object())
provider.override(object_provider)
provider_copy = providers.deepcopy(provider)
object_provider_copy = provider_copy.overridden[0]
assert provider is not provider_copy
assert provider.provides is provider_copy.provides
assert isinstance(provider, providers.Callable)
assert object_provider is not object_provider_copy
assert isinstance(object_provider_copy, providers.Object)
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,
)
class DataModels(containers.DeclarativeContainer):
config = providers.Configuration()
repositories = providers.DependenciesContainer()
#uuid = providers.Factory(uuid1)
uuid = providers.Callable(get_id)
grid_model_objective = providers.Singleton(
DatabaseBackedGridModel,
chunk_radius=config.grid.chunk_radius,
procedural=config.grid.procedural,
db=repositories.db)
grid_model_subjective = providers.Factory(SubjectiveGridModel)
being_model = providers.Factory(Being, entity_id=uuid)
class IocContainer(containers.DeclarativeContainer):
"""Application IoC container."""
config = providers.Configuration('config')
logger = providers.Singleton(logging.Logger, name='example')
# Gateways
database_client = providers.Singleton(sqlite3.connect, config.database.dsn)
s3_client = providers.Singleton(
boto3.client,
's3',
aws_access_key_id=config.aws.access_key_id,
aws_secret_access_key=config.aws.secret_access_key,
)
# Services
users_service = providers.Factory(
services.UsersService,
db=database_client,
logger=logger,
)
auth_service = providers.Factory(
services.AuthService,
token_ttl=config.auth.token_ttl,
db=database_client,
logger=logger,
)
photos_service = providers.Factory(
services.PhotosService,
db=database_client,
s3=s3_client,
logger=logger,
)
# Misc
main = providers.Callable(
main.main,
users_service=users_service,
auth_service=auth_service,
photos_service=photos_service,
)
class ActionResolvers(containers.DeclarativeContainer):
config = providers.Configuration()
managers = providers.DependenciesContainer()
rolls = providers.DependenciesContainer()
logger = providers.Singleton(
DirectNotify
)
get_resolver = providers.Callable(stub_get_resolver)
generic_action_resolver = providers.Singleton(
GenericActionResolver,
resolvers_for_type=get_resolver,
simulation_manager=managers.simulation_manager
)
movement_resolver = providers.Singleton(
MovementResolver,
simulation_manager=managers.simulation_manager,
logger=logger
)
melee_attack_resolver = providers.Singleton(
MeleeAttackResolver,
simulation_manager=managers.simulation_manager,
logger=logger
)
harvest_resolver = providers.Singleton(
HarvestResolver,
simulation_manager=managers.simulation_manager,
logger=logger
)
eat_resolver = providers.Singleton(
EatResolver,
simulation_manager=managers.simulation_manager,
logger=logger
)
observation_resolver = providers.Singleton(
ObservationResolver,
simulation_manager=managers.simulation_manager,
roll_versus_factory=rolls.roll_versus.provider,
logger=logger
)
def test_factory(self):
dependency = object()
async def _get_dependency_async():
return dependency
def _get_dependency_sync():
return dependency
provider = providers.Factory(_get_dependency_async)
dependency1 = self._run(provider())
provider.override(providers.Callable(_get_dependency_sync))
dependency2 = self._run(provider())
self.assertIs(dependency1, dependency)
self.assertIs(dependency2, dependency)
async def test_factory():
dependency = object()
async def _get_dependency_async():
return dependency
def _get_dependency_sync():
return dependency
provider = providers.Factory(_get_dependency_async)
dependency1 = await provider()
provider.override(providers.Callable(_get_dependency_sync))
dependency2 = await provider()
assert dependency1 is dependency
assert dependency2 is dependency
class NetworkSensorNode(containers.DeclarativeContainer):
broadcaster = providers.Singleton(
Broadcaster,
sense_id=Core.config.client.id,
tcp_port=Core.config.client.tcp_port,
sense_type=Core.config.client.type,
broadcast_port=Core.config.client.broadcast_port,
logger=Core.logger)
data_source = providers.Singleton(RandomDataSource)
session_manager = providers.Singleton(SessionManager,
broadcaster=broadcaster,
data_source=data_source)
run_network_sensor = providers.Callable(main,
session_manager=session_manager)
def test_isinstance(self):
dependency = 1.0
async def get_async():
return dependency
provider = providers.Dependency(instance_of=float)
provider.override(providers.Callable(get_async))
self.assertTrue(provider.is_async_mode_undefined())
dependency1 = self._run(provider())
self.assertTrue(provider.is_async_mode_enabled())
dependency2 = self._run(provider())
self.assertEqual(dependency1, dependency)
self.assertEqual(dependency2, dependency)
async def test_isinstance():
dependency = 1.0
async def get_async():
return dependency
provider = providers.Dependency(instance_of=float)
provider.override(providers.Callable(get_async))
assert provider.is_async_mode_undefined() is True
dependency1 = await provider()
assert provider.is_async_mode_enabled() is True
dependency2 = await provider()
assert dependency1 == dependency
assert dependency2 == dependency
class InterpreterStateMachineIocContainer(containers.DeclarativeContainer):
def bootstrap_container(config, logger, common_ioc, state_machine_ioc):
context_filter = common_ioc.context_filter_provider()
logger.logger.addFilter(context_filter)
InterpreterStateMachineIocContainer.instance = InterpreterStateMachineIocContainer(
config=config,
common_ioc=common_ioc,
state_machine_ioc=state_machine_ioc)
IocUtil.identify_singletons_to_be_skipped_during_deepcopy(
InterpreterStateMachineIocContainer.instance)
logger.info("container configuration complete")
return InterpreterStateMachineIocContainer.instance
common_ioc = providers.DependenciesContainer()
state_machine_ioc = providers.DependenciesContainer()
# Configuration
config = providers.Configuration('config')
logging_provider = IocUtil.create_basic_log_adapter(
providers,
"bbpyp.interpreter_state_machine",
extra={"CONTEXT_ID": None})
# Dependencies provided by third party packages
interpreter_actions_provider = providers.Dependency()
# Delegates for consumer's of this package
interpreter_state_machine_provider = providers.Singleton(
InterpreterStateMachine,
logger=logging_provider,
interpreter_actions=interpreter_actions_provider,
state_transition_builder=state_machine_ioc.
state_transition_builder_factory,
context_service=common_ioc.context_service_provider)
build = providers.Callable(bootstrap_container,
config=config,
logger=logging_provider,
common_ioc=common_ioc,
state_machine_ioc=state_machine_ioc)
class GithubNavigator(containers.DeclarativeContainer):
"""Application components container."""
config = providers.Configuration(
'config',
default={
'webapp': {
'templates_dir': 'github_navigator/templates/',
'host': '0.0.0.0',
'port': 80,
'debug': False,
},
'github': {
'request_timeout': 10.0,
},
},
)
github_searcher = providers.Factory(
searcher.GithubSearcher,
auth_token=config.github.auth_token,
request_timeout=config.github.request_timeout,
)
webapp = providers.Factory(Sanic, __name__)
template_loader = providers.Singleton(
FileSystemLoader,
searchpath=config.webapp.templates_dir,
)
template_env = providers.Singleton(
Environment,
loader=template_loader,
autoescape=select_autoescape(['html', 'xml']),
enable_async=True,
)
navigator_webhandler = providers.Callable(
webhandlers.navigator,
template_env=template_env,
github_searcher_factory=github_searcher.provider,
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
configure_logging = providers.Callable(
logging.config.fileConfig,
fname='logging.ini',
)
# Gateways
database_client = providers.Singleton(
sqlite3.connect,
config.database.dsn,
)
s3_client = providers.Singleton(
boto3.client,
service_name='s3',
aws_access_key_id=config.aws.access_key_id,
aws_secret_access_key=config.aws.secret_access_key,
)
# Services
user_service = providers.Factory(
services.UserService,
db=database_client,
)
auth_service = providers.Factory(
services.AuthService,
db=database_client,
token_ttl=config.auth.token_ttl.as_int(),
)
photo_service = providers.Factory(
services.PhotoService,
db=database_client,
s3=s3_client,
)
class AppContainer(containers.DeclarativeContainer):
DomainContainer = providers.Container(DomainContainer)
Server = providers.Factory(
Server,
get_config_use_case=DomainContainer.GetConfigUseCase,
check_if_mock_response_exists_use_case=DomainContainer.CheckIfMockResponseExistsUseCase,
check_if_proxy_server_exists_use_case=DomainContainer.CheckIfProxyServerExistsUseCase,
get_mock_response_use_case=DomainContainer.GetMockResponseUseCase,
get_proxy_server_response_use_case=DomainContainer.GetProxyServerResponseUseCase,
server_serve_func=uvicorn.run,
)
Manager = providers.Factory(
Manager,
generate_default_config_use_case=DomainContainer.GenerateDefaultConfigUseCase,
check_config_use_case=DomainContainer.CheckConfigUseCase,
server=Server,
)
create_cli = providers.Callable(
create_cli,
Manager,
)
def test_override_by_not_factory():
provider = providers.AbstractFactory(object)
with raises(errors.Error):
provider.override(providers.Callable(object))
async def main(container: Container):
resource1 = await container.resource()
container.resource.override(providers.Callable(init_resource_mock))
resource2 = await container.resource()
...
class TestServices(containers.DeclarativeContainer):
config = providers.Configuration('services')
value_getter = providers.Callable(lambda _: _, config.value)
class BentoMLContainer(containers.DeclarativeContainer):
config = providers.Configuration(strict=True)
api_server_workers = providers.Callable(
lambda workers: workers or (multiprocessing.cpu_count() // 2) + 1,
config.bento_server.workers,
)
bentoml_home = providers.Callable(
lambda: expand_env_var(
os.environ.get("BENTOML_HOME", os.path.join("~", "bentoml"))
)
)
prometheus_multiproc_dir = providers.Callable(
os.path.join, bentoml_home, "prometheus_multiproc_dir",
)
bento_bundle_deployment_version = providers.Callable(
get_bentoml_deploy_version,
providers.Callable(
lambda default, customized: customized or default,
__version__.split('+')[0],
config.bento_bundle.deployment_version,
),
)
yatai_database_url = providers.Callable(
lambda default, customized: customized or default,
providers.Callable(
"sqlite:///{}".format,
providers.Callable(os.path.join, bentoml_home, "storage.db"),
),
config.yatai.database.url,
)
yatai_file_system_directory = providers.Callable(
lambda default, customized: customized or default,
providers.Callable(os.path.join, bentoml_home, "repository"),
config.yatai.repository.file_system.directory,
)
yatai_tls_root_ca_cert = providers.Callable(
lambda current, deprecated: current or deprecated,
config.yatai.remote.tls.root_ca_cert,
config.yatai.remote.tls.client_certificate_file,
)
logging_file_directory = providers.Callable(
lambda default, customized: customized or default,
providers.Callable(os.path.join, bentoml_home, "logs",),
config.logging.file.directory,
)
yatai_logging_path = providers.Callable(
lambda default, customized: customized or default,
providers.Callable(
os.path.join, logging_file_directory, "yatai_web_server.log"
),
config.yatai.logging.path,
)
def test_traverse():
provider = providers.Callable(dict)
all_providers = list(provider.traverse())
assert len(all_providers) == 0
from dependency_injector import providers
from fastapi.testclient import TestClient
from pet_store.domain import models
from pet_store.entrypoints.api import app
from pet_store.services.unit_of_work import uow_provider
from tests.e2e.utils.testing_infrastructure import (
get_session,
destroy_testing_db,
create_testing_db,
uow_factory,
)
# Changing the UnitOfWorkFactory using the dependency_injector library
uow_provider.override(providers.Callable(uow_factory))
pre_populated_pet_id = uuid.uuid4()
pet_data = {"id": str(pre_populated_pet_id), "name": "Pimienta", "age": 1}
class PetTestCase(TestCase):
@classmethod
def setUpClass(cls) -> None:
# This has to happen in Alembic
create_testing_db()
session = get_session()
pet = models.Pet(**pet_data)
session.add(pet)
session.commit()
session.close()
class A(containers.DeclarativeContainer):
d = providers.DependenciesContainer()
bar = providers.Callable(lambda f: f + '++', d.foo.provided)
class TestCore(containers.DeclarativeContainer):
config = providers.Configuration('core')
value_getter = providers.Callable(lambda _: _, config.section.value)
