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)
