def __init__(self): """Initialize instance.""" self._factory = providers.Factory(User) super().__init__()
class Injector(containers.DeclarativeContainer): engine = providers.Factory(Engine) car = providers.Factory(Car, engine)
class Container(containers.DeclarativeContainer): service = providers.Factory(Service)
def test_init_with_not_a_factory(self): with self.assertRaises(errors.Error): providers.FactoryAggregate(example_a=providers.Factory( self.ExampleA), example_b=object())
from .dummy_widget import DummyWidgetFactory from .dummy_widget import DummyWidget class DummyNode(Node): def __init__( self, dummy_widget: DummyWidget, ): super().__init__( title="Dummy", inner_widget=dummy_widget, ) self.add_output_port("Prueba_Output1", port_type=str) self.outputs["Prueba_Output1"].set_generator_function( self.getPruebaOutput) def getPruebaOutput(self): #return self.inner_widget.get_hyperparameters() return "Hola Mundo" #def __reduce__(self): #Esto es para uso interno de pickle, para serializar objetos sin necesidad de instanciarlos #return (HyperparametersConfigNode, (self.inner_widget,), super().__getstate__()) DummyNodeFactory = providers.Factory( DummyNode, dummy_widget=DummyWidgetFactory, )
def test_repr(self): provider = providers.Factory(Example) self.assertEqual( repr(provider), '<dependency_injector.providers.' 'Factory({0}) at {1}>'.format(repr(Example), hex(id(provider))))
def setUp(self): self.delegated = providers.Factory(object) self.delegate = providers.FactoryDelegate(self.delegated)
class ListenerCount(containers.DeclarativeContainer): repositories = providers.DependenciesContainer() add = providers.Factory(Add, repo=repositories.listener_count)
if loss_function not in self._available_loss_functions: raise ValueError(f"`{loss_function}` is an invalid loss function!") self._hyperparameters[ self.Parameters.LossFunction.value] = loss_function def get_available_loss_functions(self) -> List[str]: return self._available_loss_functions def get_optimizer(self) -> str: return self._hyperparameters[self.Parameters.Optimizer.value] def set_optimizer(self, optimizer: str): if optimizer not in self._available_optimizers: raise ValueError(f"`{optimizer}` is an invalid optimizer!") self._hyperparameters[self.Parameters.Optimizer.value] = optimizer def get_available_optimizers(self) -> List[str]: return self._available_optimizers def get_batch_size(self) -> int: return self._hyperparameters[self.Parameters.BatchSize.value] def set_batch_size(self, batch_size: int): self._hyperparameters[self.Parameters.BatchSize.value] = batch_size HyperparametersConfigWidgetFactory = providers.Factory( HyperparametersConfigWidget)
self.__project_manager.active_project_changed.connect( lambda project: self.__node_editor_window.change_graphics_scene( project.graphics_scene ) ) self.__project_manager.project_removed.connect( lambda project, index: self.removeWidget(self.widget(index)) ) def setCurrentIndex(self, index: int): super().setCurrentIndex(index) tabs_widget = self.currentWidget() if not tabs_widget: return tabs_widget.insertTab(0, self.__node_editor_window, "Editor") tabs_widget.tabBar().tabButton(0, QTabBar.RightSide).deleteLater() tabs_widget.tabBar().setTabButton(0, QTabBar.RightSide, None) tabs_widget.setCurrentIndex(0) EditorTabWidgetFactory = providers.Factory( EditorTabWidget, node_editor_window_factory=NodeEditorWindowFactory.delegate(), project_manager=ProjectManagerGUISingleton, )
def get_image_transformations(self) -> List[Callable]: try: transformations = self._predefined_models_window.get_selected_model( )["transformations"] return transformations except KeyError as err: LOGGER.exception(err) return None def _update_description_labels(self, model_desc: dict): self._model_name.setText(model_desc["name"]) def _update_enabled_widgets(self): self._shape_textbox.setEnabled(not self._include_top.isChecked()) if (self._include_top.isChecked() and self._weights_combobox.currentText() == "None"): self._classes_intbox.setEnabled(True) else: self._classes_intbox.setEnabled(False) def sizeHint(self) -> "QSize": return QSize(400, 170) PredefinedModelsWidgetFactory = providers.Factory( PredefinedModelsWidget, predefined_models_window=PredefinedModelsWindowFactory)
class _Container(containers.DeclarativeContainer): p1 = providers.Dependency(instance_of=int) p2 = providers.Factory(p1)
class _Container(containers.DeclarativeContainer): p1 = providers.Dependency(instance_of=int) p2 = providers.Dependency(object) p2.override(providers.Factory(dict, p1=p1))
class _Container(containers.DeclarativeContainer): p11 = providers.Object(0) p12 = providers.Factory(dict, p11=p11)
def test_is_provider(self): self.assertTrue(providers.is_provider(providers.Factory(Example)))
def setup_module(_): subject_storage_factory.override( providers.Factory(lambda *args, **kwargs: EmptySubjectStorage()))
def test_init_with_callable(self): self.assertTrue(providers.Factory(credits))
def test_set_args(self): provider = providers.Factory(Example) \ .add_args(1, 2) \ .set_args(3, 4) self.assertEqual(provider.args, (3, 4))
def test_call_overridden_by_factory(self): provider = providers.AbstractFactory(object) provider.override(providers.Factory(Example)) self.assertIsInstance(provider(), Example)
def test_set_kwargs(self): provider = providers.Factory(Example) \ .add_kwargs(init_arg3=3, init_arg4=4) \ .set_kwargs(init_arg3=4, init_arg4=5) self.assertEqual(provider.kwargs, dict(init_arg3=4, init_arg4=5))
def setUp(self): self.example_a_factory = providers.Factory(self.ExampleA) self.example_b_factory = providers.Factory(self.ExampleB) self.factory_aggregate = providers.FactoryAggregate( example_a=self.example_a_factory, example_b=self.example_b_factory)
def test_set_attributes(self): provider = providers.Factory(Example) \ .add_attributes(attribute1=5, attribute2=6) \ .set_attributes(attribute1=6, attribute2=7) self.assertEqual(provider.attributes, dict(attribute1=6, attribute2=7))
def test_provided_instance_provider(self): provider = providers.Factory(Example) self.assertIsInstance(provider.provided, providers.ProvidedInstance)
def test_clear_args(self): provider = providers.Factory(Example) \ .add_args(1, 2) \ .clear_args() self.assertEqual(provider.args, tuple())
class Predictors(containers.DeclarativeContainer): """IoC container of predictor providers.""" """ Random predictor delivering value of last share +- Random[0,1]""" RandomPredictor = providers.Factory(RandomPredictor) """ Perfect predictors knowing future""" # Task 0 and Task 2 PerfectPredictor_stock_a = providers.Factory(PerfectPredictor, CompanyEnum.COMPANY_A) PerfectPredictor_stock_b = providers.Factory(PerfectPredictor, CompanyEnum.COMPANY_B) """Initial empty Predictors for training purposes""" """Team Blue Predictors""" # Task 1 TeamBlueStockAPredictor = providers.Factory(TeamBlueStockAPredictor) TeamBlueStockBPredictor = providers.Factory(TeamBlueStockBPredictor) """Team Green Predictors""" # Task 1 TeamGreenStockAPredictor = providers.Factory(TeamGreenStockAPredictor) TeamGreenStockBPredictor = providers.Factory(TeamGreenStockBPredictor) """Team Black Predictors""" # Task 1 TeamBlackStockAPredictor = providers.Factory(TeamBlackStockAPredictor) TeamBlackStockBPredictor = providers.Factory(TeamBlackStockBPredictor) """Team Red Predictors""" # Task 1 TeamRedStockAPredictor = providers.Factory(TeamRedStockAPredictor) TeamRedStockBPredictor = providers.Factory(TeamRedStockBPredictor)
def test_clear_kwargs(self): provider = providers.Factory(Example) \ .add_kwargs(init_arg3=3, init_arg4=4) \ .clear_kwargs() self.assertEqual(provider.kwargs, dict())
class Models(containers.DeclarativeContainer): from app.models.claim import Claim claimmodel = providers.Factory(Claim)
def test_clear_attributes(self): provider = providers.Factory(Example) \ .add_attributes(attribute1=5, attribute2=6) \ .clear_attributes() self.assertEqual(provider.attributes, dict())
def test_override_by_not_coroutine(self): provider = providers.AbstractCoroutine(_example) with self.assertRaises(errors.Error): provider.override(providers.Factory(object))
class Algorithms(containers.DeclarativeContainer): automatic_transformation = providers.Factory(AutomaticTranformation)