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 Persistance(containers.DeclarativeContainer): """Application IoC container.""" # Repositories portainer_repository = providers.Factory(PortainerRepository, Services.mongo_client) # Projections portainer_name_projection = providers.Singleton( PortainerNameProjection, Services.mongo_client, Services.domain_event_publisher, ) portainer_check_time_projection = providers.Singleton( PortainerCheckTimeProjection, Services.mongo_client, Services.domain_event_publisher, ) projections = [portainer_name_projection, portainer_check_time_projection] # Views portainer_name_view = providers.Factory(PortainerNameView, Services.mongo_client) portainer_check_time_view = providers.Factory(PortainerCheckTimeView, Services.mongo_client)
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)
class UtilityClientScopeProvider(containers.DeclarativeContainer): """IoC container of utilities providers.""" database_client = providers.Singleton(DatabaseUtil) time_zone_client = providers.Singleton(TimeUtil) logging_client = providers.Singleton(LoggingUtil) network_client = providers.Singleton(NetworkUtil)
class Container(containers.DeclarativeContainer): config_handler = providers.Singleton( ConfigHandler ) telegram_client = providers.Singleton( MyTelegramClient, config_handler=config_handler ) data_handler = providers.Factory( DataHandler, config_handler=config_handler ) telegram_handler = providers.Factory( TelegramHandler, telegram_client=telegram_client ) tracking_handler = providers.Factory( TrackingHandler, telegram_handler=telegram_handler, config_handler=config_handler, data_handler=data_handler )
def init(): configs_factory.override( providers.Singleton(lambda: krules_settings) ) proc_events_rx_factory.override( providers.Singleton(rx.subjects.ReplaySubject) ) event_router_factory.override( providers.Singleton(lambda: EventRouter()) ) exceptions_dumpers = exceptions_dumpers_factory() exceptions_dumpers.set(ExceptionDumperBase) exceptions_dumpers.set(RequestsHTTPErrorDumper) # TODO: do it better source = None if "K_SERVICE" in os.environ: source = os.environ["K_SERVICE"] elif "SERVICE" in os.environ: source = os.environ["SERVICE"] else: source = socket.gethostname() from krules_cloudevents.route.dispatcher import CloudEventsDispatcher event_dispatcher_factory.override( providers.Singleton(lambda: CloudEventsDispatcher(krules_settings["CLOUDEVENTS"]["send_to"], source)) )
class FleaMarketContainer(containers.DeclarativeContainer): flea_config: Dependency[FleaMarketConfig] = providers.Dependency() templates_repository: Dependency[ItemTemplatesRepository] = providers.Dependency() globals_repository: Dependency[GlobalsRepository] = providers.Dependency() item_factory: Dependency[ItemFactory] = providers.Dependency() generator: providers.Provider[OfferGenerator] = providers.Singleton( OfferGenerator, config=flea_config, templates_repository=templates_repository, globals_repository=globals_repository, item_factory=item_factory, ) view: providers.Provider[FleaMarketView] = providers.Factory( FleaMarketView, templates_repository=templates_repository, ) market: providers.Provider[FleaMarket] = providers.Singleton( FleaMarket, offer_generator=generator, flea_view_factory=view.provider, flea_config=flea_config, )
class ManagerProvider: cfg = providers.Singleton(Config, cfg=DATABASE) manager = providers.Singleton(ManagerInterface, cfg=cfg().cfg)() def get_processor(self, id_processor=None): try: print(self.manager.get_processor(id_processor)) except lacksError: print('Processor does not exists.') def insert_new_processor(self, **kwargs): try: self.manager.insert_new_processor(**kwargs) except KeyError: print('Fields name and price are required!') def remove_processor(self, id_processor=None): try: self.manager.remove_processor(id_processor) except TypeError: print('Processor id has no exist.') def update_characteristics(self, id_processor=None, **kwargs): try: self.manager.update_characteristics(id_processor, **kwargs) except TypeError: print('Processor id has no exist.') except lacksError: print('Processor does not exists.') def get_count(self): print(self.cfg().count)
def init(): blackboard.account_cache = providers.Singleton(AccountCache, db=blackboard.database) account_repository.provided_by( providers.Singleton(DbAccountRepository, db=blackboard.database, cache=blackboard.account_cache))
class Services(containers.DeclarativeContainer): config_loader = providers.Singleton(ConfigLoaderService) http = providers.Singleton(HttpService, Configs.http) pokemon = providers.Singleton(PokemonService, Configs.pokemon, http_service=http) s3 = providers.Singleton(S3Service, Configs.s3)
class ManeuverResolvers(containers.DeclarativeContainer): config = providers.Configuration() managers = providers.DependenciesContainer() action_resolvers = providers.DependenciesContainer() logger = providers.Singleton( DirectNotify ) passive_observation_resolver = providers.Singleton( PassiveObservationManeuverResolver, simulation_manager=managers.simulation_manager, logger=logger, generic_resolver=action_resolvers.generic_action_resolver ) movement_resolver = providers.Singleton( MoveManeuverResolver, simulation_manager=managers.simulation_manager, logger=logger, generic_resolver=action_resolvers.generic_action_resolver ) move_attack_resolver = providers.Singleton( MoveAttackManeuverResolver, simulation_manager=managers.simulation_manager, logger=logger, generic_resolver=action_resolvers.generic_action_resolver ) yield_turn_resolver = providers.Singleton( YieldTurnManeuverResolver, simulation_manager=managers.simulation_manager, logger=logger, generic_resolver=action_resolvers.generic_action_resolver )
class SchedulerDomain(containers.DeclarativeContainer): """IoC container of service providers.""" inter_domain_event_bindings = providers.Object({ strongr.core.domain.clouddomain.CloudDomain.events()['jobfinished']: { # command / query generators based on event 'command': [(lambda event: SchedulerDomain.commandFactory().newJobFinished( event.job_id, event.ret, event.retcode)) #, #(lambda event: SchedulerDomain.commandFactory().newRunEnqueuedJobs()) ] }, strongr.core.domain.clouddomain.CloudDomain.events()['vmnew']: { 'command': [(lambda event: SchedulerDomain.commandFactory().newVmNew( event.vm_id, event.cores, event.ram))] }, strongr.core.domain.clouddomain.CloudDomain.events()['vmcreated']: { 'command': [(lambda event: SchedulerDomain.commandFactory(). newVmCreated(event.vm_id))] }, strongr.core.domain.clouddomain.CloudDomain.events()['vmready']: { 'command': [(lambda event: SchedulerDomain.commandFactory(). newVmReady(event.vm_id))] }, strongr.core.domain.clouddomain.CloudDomain.events()['vmdestroyed']: { 'command': [(lambda event: SchedulerDomain.commandFactory(). newVmDestroyed(event.vm_id))] } }) schedulerService = providers.Singleton(SchedulerService, inter_domain_event_bindings()) commandFactory = providers.Singleton(CommandFactory) queryFactory = providers.Singleton(QueryFactory)
class Core(containers.DeclarativeContainer): """IoC container of core component providers.""" config = providers.Configuration('config') inter_domain_events_publisher = providers.Singleton(EventsPublisher, 'InterDomain') command_router = providers.Singleton(CommandRouter)
class Container(containers.DeclarativeContainer): # settings settings = providers.Configuration() # database db = providers.Singleton(Database, db_url=settings.DB_URL) # repository user_repository = providers.Singleton(OrmUserRepository, session_factory=db.provided.session) review_repository = providers.Singleton( OrmReviewRepository, session_factory=db.provided.session) wish_repository = providers.Singleton(OrmWishRepository, session_factory=db.provided.session) drink_repository = providers.Singleton(OrmDrinkRepository, session_factory=db.provided.session) # application service user_application_service = providers.Singleton( UserApplicationService, user_repository=user_repository) auth_application_service = providers.Singleton( AuthApplicationService, user_application_service=user_application_service, jwt_secret_key=settings.JWT_SECRET_KEY, jwt_algorithm=settings.JWT_ALGORITHM, ) review_application_service = providers.Singleton( ReviewApplicationService, review_repository=review_repository) wish_application_service = providers.Singleton( WishApplicationService, wish_repository=wish_repository) drink_application_service = providers.Singleton( DrinkApplicationService, drink_repository=drink_repository)
class Container(containers.DeclarativeContainer): config = providers.Configuration(yaml_files=["config.yml"]) 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 ConfigContainer(containers.DeclarativeContainer): flea_market = providers.Singleton( config.FleaMarketConfig.load, ) bot_generation = providers.Singleton(config.BotGenerationConfig.load) traders = providers.Singleton(config.TradersConfig.load)
class FakeServices(containers.DeclarativeContainer): config = providers.Configuration("config") authentication = providers.Singleton(AuthenticationTestAdapter, config.user_id) permission = providers.Singleton(PermissionTestAdapter) database = providers.Singleton(DatabaseTestAdapter) event_store = providers.Singleton(EventStoreTestAdapter)
class Containers(containers.DeclarativeContainer): config = providers.Configuration() logging = providers.Resource( logging.config.fileConfig, fname=os.path.join(os.getcwd(), "logging.ini") ) # declare objects initialize trigger_factory = providers.Factory(TriggerFactory) sched_event_listener = providers.Factory(SchedulerEventListener) scheduler = providers.Singleton( ScheduleManager, config = config.sched_config, event_listener = sched_event_listener ) custom_handler = providers.Singleton( ExampleSubscribeHandler, scheduler = scheduler, trigger_fac = trigger_factory ) remote_service = providers.Singleton( SubscribeRpcService, scheduler = scheduler, subscribe_handler = custom_handler )
class Repositories(containers.DeclarativeContainer): user_repo = providers.Singleton(UserRepository, database=Databases.database) physical_stats_repo = providers.Singleton(PhysicalStatsRepository, database=Databases.database) product_repo = providers.Singleton(ProductRepository, database=Databases.database)
class ApplicationContainer(containers.DeclarativeContainer): config = providers.Configuration(ini_files=["config.ini"]) 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() movie: providers.Factory[entities.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, ) orm_sqlite_finder = providers.Singleton( finders.ORMSqliteFinder, movie_factory=movie.provider, path=config.finder.sqlite.path, ) finder = providers.Selector( config.finder.type, csv=csv_finder, sqlite=sqlite_finder, orm_sqlite=orm_sqlite_finder, ) lister = providers.Factory(listers.MovieLister, movie_finder=finder)
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): config = providers.Configuration() logging = providers.Resource( logging.basicConfig, stream=sys.stdout, level=config.log.level, format=config.log.format, ) coloredlogs.install() sessions = providers.Singleton(session_storage.SessionStorage, config.telegram) configurator = providers.Singleton(Configurator, sessions) mqtt = providers.Singleton(Mosquitto, configurator, sessions, config.mqtt) startup = providers.Singleton(Startup, sessions, mqtt) dispatcher = providers.Factory(dispatcher.Dispatcher, dispatchables=providers.List( mqtt, startup, ))
class Services(containers.DeclarativeContainer): user_service = providers.Singleton(UserService, Repositories.user_repo) physical_stats_service = providers.Singleton( PhysicalStatsService, Repositories.physical_stats_repo, Repositories.user_repo) product_service = providers.Singleton(ProductService, Repositories.product_repo)
class FakeServicesOld(containers.DeclarativeContainer): config = providers.Configuration("config") authentication = providers.Singleton(AuthenticationTestAdapter, config.user_id) superuser = providers.Configuration("superuser") permission = providers.Singleton(PermissionTestAdapter, superuser) datastore = providers.Singleton(DatabaseTestAdapter, old_style_testing=True)
class Services(containers.DeclarativeContainer): identity_scanner = providers.Singleton(DummyScanner, logger=Core.logger) presence_processor = providers.Singleton(FilePresenceProcessor, logger=Core.logger, presence_logger=Core.presence_logger, target=Core.config.target, max_disconnect_pings=Core.config.max_disconnect_pings)
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)
class HandlerInjector(containers.DeclarativeContainer): """ Handler """ FindUserQuery = providers.Singleton( FindUserQueryHandler, service=AppServicesInjector.user_finder) CreateUserCommand = providers.Singleton( CreateUserCommandHandler, service=AppServicesInjector.user_create)
class RepositoryInjector(containers.DeclarativeContainer): """ Repository """ user_mng = providers.Singleton(UserSqlMngRepository, adapter=AdapterInjector.sql_alchemy) user_finder = providers.Singleton(UserSqlFinderRepository, adapter=AdapterInjector.sql_alchemy)
def create_basic_log_adapter(providers, name, extra=None): log_message_factory_provider = providers.DelegatedFactory(Message) logger = providers.Singleton(logging.getLogger, name=name) return providers.Singleton( BasicLogAdapter, logger, log_message_factory=log_message_factory_provider, extra=extra)