Create PowerEvaluator data source

which raise the input value to the power of what's given in the model

force_bdss/core_plugins/dummy/dummy_plugin.py

@@ -3,6 +3,7 @@ from .dummy_notification_listener.dummy_notification_listener_factory import (
     DummyNotificationListenerFactory
 )
 from .csv_extractor.csv_extractor_factory import CSVExtractorFactory
+from .power_evaluator.power_evaluator_factory import PowerEvaluatorFactory
 from .kpi_adder.kpi_adder_factory import KPIAdderFactory
 from .dummy_dakota.dakota_factory import DummyDakotaFactory
 from .dummy_data_source.dummy_data_source_factory import DummyDataSourceFactory
@@ -16,7 +17,8 @@ class DummyPlugin(BaseExtensionPlugin):
 
     def _data_source_factories_default(self):
         return [DummyDataSourceFactory(self),
-                CSVExtractorFactory(self)]
+                CSVExtractorFactory(self),
+                PowerEvaluatorFactory(self)]
 
     def _mco_factories_default(self):
         return [DummyDakotaFactory(self)]

force_bdss/core_plugins/dummy/power_evaluator/power_evaluator_data_source.py

+import math
+
+from force_bdss.api import BaseDataSource, DataValue
+from force_bdss.core.slot import Slot
+
+
+class PowerEvaluatorDataSource(BaseDataSource):
+    def run(self, model, parameters):
+        x = parameters[0].value
+        return [
+            DataValue(
+                type=model.cuba_type_out,
+                value=math.pow(x, model.power)
+            )]
+
+    def slots(self, model):
+        return (
+            (
+                Slot(type=model.cuba_type_in),
+            ),
+            (
+                Slot(type=model.cuba_type_out),
+            )
+        )

force_bdss/core_plugins/dummy/power_evaluator/power_evaluator_factory.py

+from traits.api import String
+
+from force_bdss.api import factory_id, BaseDataSourceFactory
+
+from .power_evaluator_model import PowerEvaluatorModel
+from .power_evaluator_data_source import PowerEvaluatorDataSource
+
+
+class PowerEvaluatorFactory(BaseDataSourceFactory):
+    id = String(factory_id("enthought", "power_evaluator"))
+
+    name = String("Power Evaluator")
+
+    def create_model(self, model_data=None):
+        if model_data is None:
+            model_data = {}
+
+        return PowerEvaluatorModel(self, **model_data)
+
+    def create_data_source(self):
+        return PowerEvaluatorDataSource(self)

force_bdss/core_plugins/dummy/power_evaluator/power_evaluator_model.py

+from traits.api import Float, String, on_trait_change
+
+from force_bdss.api import BaseDataSourceModel
+
+
+class PowerEvaluatorModel(BaseDataSourceModel):
+    power = Float()
+    cuba_type_in = String()
+    cuba_type_out = String()
+
+    @on_trait_change("cuba_type_in,cuba_type_out")
+    def _notify_changes_slots(self):
+        self.changes_slots = True

force_bdss/core_plugins/dummy/power_evaluator/tests/test_power_evaluator_data_source.py

+import unittest
+
+from force_bdss.core.data_value import DataValue
+from force_bdss.core.slot import Slot
+from force_bdss.core_plugins.dummy.power_evaluator.power_evaluator_data_source import PowerEvaluatorDataSource  # noqa
+from force_bdss.core_plugins.dummy.power_evaluator.power_evaluator_model import PowerEvaluatorModel  # noqa
+from force_bdss.data_sources.base_data_source_factory import \
+    BaseDataSourceFactory
+from force_bdss.tests import fixtures
+
+try:
+    import mock
+except ImportError:
+    from unittest import mock
+
+
+class TestPowerEvaluatorDataSource(unittest.TestCase):
+    def setUp(self):
+        self.factory = mock.Mock(spec=BaseDataSourceFactory)
+
+    def test_initialization(self):
+        ds = PowerEvaluatorDataSource(self.factory)
+        self.assertEqual(ds.factory, self.factory)
+
+    def test_run(self):
+        ds = PowerEvaluatorDataSource(self.factory)
+        model = PowerEvaluatorModel(self.factory)
+        model.power = 2
+        mock_params = [DataValue(value=5, type="METER")]
+        result = ds.run(model, mock_params)
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 1)
+        self.assertIsInstance(result[0], DataValue)
+        self.assertEqual(result[0].value, 25)
+
+    def test_run_with_exception(self):
+        ds = PowerEvaluatorDataSource(self.factory)
+        model = PowerEvaluatorModel(self.factory)
+        mock_params = []
+        model.power = 3
+        with self.assertRaises(IndexError):
+            ds.run(model, mock_params)
+
+    def test_slots(self):
+        ds = PowerEvaluatorDataSource(self.factory)
+        model = PowerEvaluatorModel(self.factory)
+        slots = ds.slots(model)
+        self.assertEqual(len(slots), 2)
+        self.assertEqual(len(slots[0]), 1)
+        self.assertEqual(len(slots[1]), 1)
+        self.assertIsInstance(slots[0][0], Slot)
+        self.assertIsInstance(slots[1][0], Slot)

force_bdss/core_plugins/dummy/power_evaluator/tests/test_power_evaluator_factory.py

+import unittest
+
+from force_bdss.core_plugins.dummy.tests.data_source_factory_test_mixin \
+    import DataSourceFactoryTestMixin
+from force_bdss.core_plugins.dummy.power_evaluator.power_evaluator_factory import PowerEvaluatorFactory  # noqa
+from force_bdss.core_plugins.dummy.power_evaluator.power_evaluator_data_source import PowerEvaluatorDataSource  # noqa
+from force_bdss.core_plugins.dummy.power_evaluator.power_evaluator_model import PowerEvaluatorModel  # noqa
+
+
+class TestPowerEvaluatorFactory(DataSourceFactoryTestMixin,
+                                unittest.TestCase):
+    @property
+    def factory_class(self):
+        return PowerEvaluatorFactory
+
+    @property
+    def model_class(self):
+        return PowerEvaluatorModel
+
+    @property
+    def data_source_class(self):
+        return PowerEvaluatorDataSource