class Repositories(containers.DeclarativeContainer):
config = providers.Configuration()
db = providers.Factory(
Database,
conn_str=config.connection_string
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
movie = providers.Factory(entities.Movie)
csv_finder = providers.Singleton(
finders.CsvMovieFinder,
movie_factory=movie.provider,
path=config.finder.csv.path,
delimiter=config.finder.csv.delimiter,
)
sqlite_finder = providers.Singleton(
finders.SqliteMovieFinder,
movie_factory=movie.provider,
path=config.finder.sqlite.path,
)
finder = providers.Selector(
config.finder.type,
csv=csv_finder,
sqlite=sqlite_finder,
)
lister = providers.Factory(
listers.MovieLister,
movie_finder=finder,
)
class NestedContainer(containers.DeclarativeContainer):
settings = providers.Configuration()
print_settings = providers.Callable(
lambda s: s,
settings,
)
def test_providers_with_default_value_overriding(self):
self.config = providers.Configuration(
name='config', default={'a': {
'b': {
'c': 1,
'd': 2
}
}})
self.assertEqual(self.config.a(), {'b': {'c': 1, 'd': 2}})
self.assertEqual(self.config.a.b(), {'c': 1, 'd': 2})
self.assertEqual(self.config.a.b.c(), 1)
self.assertEqual(self.config.a.b.d(), 2)
self.config.override({'a': {'b': {'c': 3, 'd': 4}}})
self.assertEqual(self.config.a(), {'b': {'c': 3, 'd': 4}})
self.assertEqual(self.config.a.b(), {'c': 3, 'd': 4})
self.assertEqual(self.config.a.b.c(), 3)
self.assertEqual(self.config.a.b.d(), 4)
self.config.reset_override()
self.assertEqual(self.config.a(), {'b': {'c': 1, 'd': 2}})
self.assertEqual(self.config.a.b(), {'c': 1, 'd': 2})
self.assertEqual(self.config.a.b.c(), 1)
self.assertEqual(self.config.a.b.d(), 2)
class IocContainer(containers.DeclarativeContainer):
"""
Define dependencies and inject them into data and service layers when creating Flask app.
"""
config = providers.Configuration('config', default={
'SQLALCHEMY_DATABASE_URI': 'mysql+pymysql://root:@localhost/community',
'LOG_PATH': 'rest-api-prototype.log',
'SQLALCHEMY_ECHO': True,
'CACHE_TYPE': 'simple',
'CACHE_DEFAULT_TIMEOUT': 300
})
app = providers.Factory(Flask, __name__)
cache = providers.Dependency(instance_of=Cache)
logger = providers.Dependency(instance_of=Logger)
db = providers.Dependency(instance_of=SQLAlchemy)
db_session = providers.Dependency(instance_of=ScopedSession)
community_dao = providers.Dependency(instance_of=CommunityDao)
community_service = providers.Singleton(CommunityService, community_dao, logger)
class Core(containers.DeclarativeContainer):
config = providers.Configuration('config')
logger = providers.Singleton(logging.Logger, name='log')
presence_logger = providers.Singleton(logging.Logger, name='presence_logger')
class Container(containers.DeclarativeContainer):
app = flask.Application(Flask, __name__)
# Configuración
config = providers.Configuration('config')
# Dependencias
logger = providers.Singleton(logging.Logger, name='logger')
psycopg2_data_manager = providers.Singleton(Psycopg2DataManager,
user=config.username,
password=config.password,
host=config.host,
port=config.port,
db_name=config.db_name)
sqlalchemy_orm_data_manager = providers.Singleton(SqlAlchemyORMDataManager,
user=config.username,
password=config.password,
host=config.host,
port=config.port,
db_name=config.db_name)
# Servicios
gestor_pedidos = providers.Selector(
config.data_handler,
psycopg2=providers.Singleton(GestorPedidos, psycopg2_data_manager,
logger),
sqlalchemy=providers.Singleton(GestorPedidos,
sqlalchemy_orm_data_manager, logger),
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
active_url = None
active_token = None
log = providers.Resource(
logging.config.fileConfig,
fname="logging.ini",
)
if config.application.environment:
active_url = config.uat.url
active_token = config.uat.token
else:
# Set as per Environment
url = None
token = None
client_session = providers.Singleton(Session)
b2c2_client = providers.Factory(
B2C2Client,
session=client_session,
url=active_url,
token=active_token,
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
notify_service = providers.Singleton(NotifyService,
api_key=config.NOTIFY_API_KEY,
end_point=config.NOTIFY_ENDPOINT)
def setUp(self):
self.config = providers.Configuration(name='config')
class Section11(pydantic.BaseModel):
value1 = 1
class Section12(pydantic.BaseModel):
value2 = 2
class Settings1(pydantic.BaseSettings):
section1 = Section11()
section2 = Section12()
self.Settings1 = Settings1
class Section21(pydantic.BaseModel):
value1 = 11
value11 = 11
class Section3(pydantic.BaseModel):
value3 = 3
class Settings2(pydantic.BaseSettings):
section1 = Section21()
section3 = Section3()
self.Settings2 = Settings2
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
database = providers.Singleton(
databases.Database,
url=config.db.connection_string
)
var_service = providers.Factory(
VariableService,
database=database
)
env_service = providers.Factory(
EnvironmentService,
database=database,
var_service=var_service
)
app_service = providers.Factory(
ApplicationService,
database=database,
env_service=env_service
)
change_history_service = providers.Factory(
ChangeHistoryService,
database=database,
app_service=app_service,
env_service=env_service,
var_service=var_service
)
def test_double_override():
root_config = providers.Configuration("main")
core = Core(config=root_config.core)
services = Services(config=root_config.services)
root_config.override(
{
"core": {
"value": "core1",
},
"services": {
"value": "services1",
},
}, )
root_config.override(
{
"core": {
"value": "core2",
},
"services": {
"value": "services2",
},
}, )
assert core.config() == {"value": "core2"}
assert core.config.value() == "core2"
assert core.value_getter() == "core2"
assert services.config() == {"value": "services2"}
assert services.config.value() == "services2"
assert services.value_getter() == "services2"
class ApplicationContainer(containers.DeclarativeContainer):
config = providers.Configuration()
sqlite = providers.Singleton(sqlite3.connect, config.database.dsn)
s3 = 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,
)
user_package = providers.Container(
UserContainer,
database=sqlite,
)
photo_package = providers.Container(
PhotoContainer,
database=sqlite,
file_storage=s3,
)
analytics_package = providers.Container(
AnalyticsContainer,
user_repository=user_package.user_repository,
photo_repository=photo_package.photo_repository,
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
config.from_ini('./GiysApi/config.ini')
rmq = config.RMQ
logger = providers.Factory(Logger)
rmq_connection = providers.Factory(Connection,
hostname=rmq.hostname,
username=rmq.username,
password=rmq.password)
task_logger = providers.Factory(TaskLogger)
register_manager = providers.Factory(RegisterManager)
message_handler = providers.Factory(MessageHandler,
task_logger=task_logger,
register_manager=register_manager)
message_consumer = providers.Factory(MessageConsumer,
connection=rmq_connection,
message_handler=message_handler,
logger=logger)
message_service = providers.Factory(MessageService,
connection=rmq_connection)
task_manager = providers.Factory(TaskManager,
message_service=message_service,
task_logger=task_logger)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
session = providers.Resource(
boto3.session.Session,
aws_access_key_id=config.aws_access_key_id,
aws_secret_access_key=config.aws_secret_access_key,
aws_session_token=config.aws_session_token,
)
s3_client = providers.Resource(
session.provided.client.call(),
service_name="s3",
)
sqs_client = providers.Resource(
providers.MethodCaller(session.provided.client), # Alternative syntax
service_name="sqs",
)
service1 = providers.Factory(
Service,
s3_client=s3_client,
sqs_client=sqs_client,
)
service2 = providers.Factory(
Service,
s3_client=session.provided.client.call(
service_name="s3"), # Alternative inline syntax
sqs_client=session.provided.client.call(
service_name="sqs"), # Alternative inline syntax
)
def test_double_override(self):
root_config = providers.Configuration('main')
core = self.TestCore(config=root_config.core)
services = self.TestServices(config=root_config.services)
root_config.override(
{
'core': {
'value': 'core1',
},
'services': {
'value': 'services1',
},
},
)
root_config.override(
{
'core': {
'value': 'core2',
},
'services': {
'value': 'services2',
},
},
)
self.assertEqual(core.config(), {'value': 'core2'})
self.assertEqual(core.config.value(), 'core2')
self.assertEqual(core.value_getter(), 'core2')
self.assertEqual(services.config(), {'value': 'services2'})
self.assertEqual(services.config.value(), 'services2')
self.assertEqual(services.value_getter(), 'services2')
class HeaterControlContainer(containers.DeclarativeContainer):
config = providers.Configuration()
first_heater_controller = providers.Factory(RelayController, 2)
second_heater_controller = providers.Factory(RelayController, 4)
heater_status_repository = providers.Singleton(HeaterStatusRepository,
first_heater_controller,
second_heater_controller)
class Core(containers.DeclarativeContainer):
""" the container for core components of the program """
config = providers.Configuration('config')
logger = providers.Singleton(Logger,
name=config.logging.name,
view_level=config.logging.level)
class ApplicationContainer(containers.DeclarativeContainer):
"""Application container."""
app = flask.Application(Flask, __name__)
bootstrap = flask.Extension(Bootstrap)
config = providers.Configuration()
github_client = providers.Factory(
Github,
login_or_token=config.github.auth_token,
timeout=config.github.request_timeout,
)
search_service = providers.Factory(
services.SearchService,
github_client=github_client,
)
index_view = flask.View(
views.index,
search_service=search_service,
default_query=config.search.default_query,
default_limit=config.search.default_limit,
)
def test_forward_attr_to_default(self):
default = providers.Configuration()
provider = providers.Dependency(default=default)
provider.from_dict({'foo': 'bar'})
self.assertEqual(default(), {'foo': 'bar'})
class ApplicationContainer(containers.DeclarativeContainer):
"""Application container."""
config = providers.Configuration()
configure_logging = providers.Callable(
logging.basicConfig,
stream=sys.stdout,
level=config.log.level,
format=config.log.format,
)
http_client = providers.Factory(http.HttpClient)
example_monitor = providers.Factory(
monitors.HttpMonitor,
http_client=http_client,
options=config.monitors.example,
)
httpbin_monitor = providers.Factory(
monitors.HttpMonitor,
http_client=http_client,
options=config.monitors.httpbin,
)
dispatcher = providers.Factory(
dispatcher.Dispatcher,
monitors=providers.List(
example_monitor,
httpbin_monitor,
),
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
logger = providers.Singleton(LoggingHandler, log_level=config.LOG_LEVEL)
api_client = providers.Singleton(ApiClient, logger=logger)
db_handler = providers.Singleton(DbHandler,
logger=logger,
mongo_uri=config.MONGO_URI,
mongo_db_name=config.MONGO_DBNAME)
bot = providers.Singleton(commands.Bot,
command_prefix=config.PREFIX,
help_command=None)
main_cog = providers.Singleton(
MainCog,
logger=logger,
discord_bot=bot,
db_handler=db_handler,
api_client=api_client,
)
service = providers.Factory(BotService,
logger=logger,
bot=bot,
main_cog=main_cog,
discord_token=config.DISCORD_TOKEN)
def test_traverse_overridden_option_2():
options = {"option2": "option2"}
config = providers.Configuration()
config.option1.from_dict(options)
all_providers = list(config.option1.traverse())
assert len(all_providers) == 0
def setUp(self):
self.config = providers.Configuration(name='config')
os.environ['CONFIG_TEST_ENV'] = 'test-value'
_, self.config_file = tempfile.mkstemp()
with open(self.config_file, 'w') as config_file:
config_file.write('section1:\n' ' value1: ${CONFIG_TEST_ENV}\n')
def test_forward_attr_to_overriding(self):
overriding = providers.Configuration()
provider = providers.Dependency()
provider.override(overriding)
provider.from_dict({'foo': 'bar'})
self.assertEqual(overriding(), {'foo': 'bar'})
class Core(containers.DeclarativeContainer):
"""IoC container of core component providers."""
config = providers.Configuration('config')
logger = providers.Singleton(logging.Logger, name='application')
loop = providers.Singleton(asyncio.get_event_loop)
def test_traverse_overridden_option_2(self):
options = {'option2': 'option2'}
config = providers.Configuration()
config.option1.from_dict(options)
all_providers = list(config.option1.traverse())
self.assertEqual(len(all_providers), 0)
class GADMLoaderContainer(containers.DeclarativeContainer):
"""
DI Container
"""
config = providers.Configuration()
disk_cache = providers.Singleton(DiskCacheProvider, disk_cache=config.disk_cache)
service = providers.Factory(GADMLoaderService, disk_cache=disk_cache)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
calculator_factory = providers.Factory(
Calculator,
pi=config.pi.as_(decimal.Decimal),
)
class Core(containers.DeclarativeContainer):
config = providers.Configuration()
configure_logging = providers.Callable(
logging.config.dictConfig,
config=config.logging,
)