Merge pull request #120 from force-h2020/remove-kpi

Allow KPIs to be specified as datasource outputs.

force_bdss/kpi/tests/test_base_kpi_calculator_factory.py

-import unittest
-import testfixtures
-from envisage.plugin import Plugin
-
-from force_bdss.kpi.tests.test_base_kpi_calculator import DummyKPICalculator
-from force_bdss.kpi.tests.test_base_kpi_calculator_model import \
-    DummyKPICalculatorModel
-
-try:
-    import mock
-except ImportError:
-    from unittest import mock
-
-from force_bdss.kpi.base_kpi_calculator_factory import \
-    BaseKPICalculatorFactory
-
-
-class DummyKPICalculatorFactory(BaseKPICalculatorFactory):
-    id = "foo"
-
-    name = "bar"
-
-    def create_kpi_calculator(self):
-        pass
-
-    def create_model(self, model_data=None):
-        pass
-
-
-class DummyKPICalculatorFactoryFast(BaseKPICalculatorFactory):
-    id = "foo"
-
-    name = "bar"
-
-    kpi_calculator_class = DummyKPICalculator
-
-    model_class = DummyKPICalculatorModel
-
-
-class TestBaseKPICalculatorFactory(unittest.TestCase):
-    def test_initialization(self):
-        factory = DummyKPICalculatorFactory(mock.Mock(spec=Plugin))
-        self.assertEqual(factory.id, 'foo')
-        self.assertEqual(factory.name, 'bar')
-
-    def test_fast_definition(self):
-        factory = DummyKPICalculatorFactoryFast(mock.Mock(spec=Plugin))
-        self.assertIsInstance(factory.create_kpi_calculator(),
-                              DummyKPICalculator)
-
-        self.assertIsInstance(factory.create_model(),
-                              DummyKPICalculatorModel)
-
-    def test_fast_definition_errors(self):
-        factory = DummyKPICalculatorFactoryFast(mock.Mock(spec=Plugin))
-        factory.kpi_calculator_class = None
-        factory.model_class = None
-
-        with testfixtures.LogCapture():
-            with self.assertRaises(RuntimeError):
-                factory.create_kpi_calculator()
-
-            with self.assertRaises(RuntimeError):
-                factory.create_model()

force_bdss/kpi/tests/test_base_kpi_calculator_model.py

-import unittest
-
-from force_bdss.core.input_slot_info import InputSlotInfo
-from force_bdss.core.output_slot_info import OutputSlotInfo
-from force_bdss.kpi.base_kpi_calculator_factory import BaseKPICalculatorFactory
-from force_bdss.kpi.base_kpi_calculator_model import BaseKPICalculatorModel
-
-try:
-    import mock
-except ImportError:
-    from unittest import mock
-
-
-class DummyKPICalculatorModel(BaseKPICalculatorModel):
-    pass
-
-
-class TestBaseKPICalculatorModel(unittest.TestCase):
-    def test_getstate(self):
-        model = DummyKPICalculatorModel(
-            mock.Mock(spec=BaseKPICalculatorFactory))
-        self.assertEqual(
-            model.__getstate__(),
-            {
-                "__traits_version__": "4.6.0",
-                "input_slot_info": [],
-                "output_slot_info": []
-            })
-
-        model.input_slot_info = [
-            InputSlotInfo(name="foo"),
-            InputSlotInfo(name="bar")
-        ]
-        model.output_slot_info = [
-            OutputSlotInfo(name="baz"),
-            OutputSlotInfo(name="quux")
-        ]
-
-        self.assertEqual(
-            model.__getstate__(),
-            {
-                "__traits_version__": "4.6.0",
-                "input_slot_info": [
-                    {
-                        "__traits_version__": "4.6.0",
-                        "source": "Environment",
-                        "name": "foo"
-                    },
-                    {
-                        "__traits_version__": "4.6.0",
-                        "source": "Environment",
-                        "name": "bar"
-                    }
-                ],
-                "output_slot_info": [
-                    {
-                        "__traits_version__": "4.6.0",
-                        "name": "baz",
-                        "is_kpi": False,
-                    },
-                    {
-                        "__traits_version__": "4.6.0",
-                        "name": "quux",
-                        "is_kpi": False,
-                    }
-                ]
-            })

force_bdss/tests/probe_classes/factory_registry_plugin.py

@@ -3,7 +3,6 @@ from traits.api import List, HasStrictTraits, provides
 from force_bdss.factory_registry_plugin import IFactoryRegistryPlugin
 
 from .mco import ProbeMCOFactory
-from .kpi_calculator import ProbeKPICalculatorFactory
 from .data_source import ProbeDataSourceFactory
 from .notification_listener import ProbeNotificationListenerFactory
 from .ui_hooks import ProbeUIHooksFactory
@@ -20,9 +19,6 @@ class ProbeFactoryRegistryPlugin(HasStrictTraits):
     def _mco_factories_default(self):
         return [ProbeMCOFactory(None)]
 
-    def _kpi_calculator_factories_default(self):
-        return [ProbeKPICalculatorFactory(None)]
-
     def _data_source_factories_default(self):
         return [ProbeDataSourceFactory(None)]
 

force_bdss/tests/probe_classes/kpi_calculator.py

-from traits.api import Bool, Function, Str, Int, on_trait_change, Type
-
-from force_bdss.ids import factory_id
-from force_bdss.api import (
-    BaseKPICalculatorFactory, BaseKPICalculatorModel, BaseKPICalculator,
-    Slot
-)
-
-from .evaluator_factory import ProbeEvaluatorFactory
-
-
-def run_func(*args, **kwargs):
-    return []
-
-
-class ProbeKPICalculator(BaseKPICalculator):
-    run_function = Function(default_value=run_func)
-
-    run_called = Bool(False)
-    slots_called = Bool(False)
-
-    def run(self, model, parameters):
-        self.run_called = True
-        return self.run_function(model, parameters)
-
-    def slots(self, model):
-        self.slots_called = True
-        return (
-            tuple(Slot(type=model.input_slots_type)
-                  for _ in range(model.input_slots_size))
-        ), (
-            tuple(Slot(type=model.output_slots_type)
-                  for _ in range(model.output_slots_size))
-        )
-
-
-class ProbeKPICalculatorModel(BaseKPICalculatorModel):
-    input_slots_type = Str('PRESSURE')
-    output_slots_type = Str('PRESSURE')
-
-    input_slots_size = Int(0)
-    output_slots_size = Int(0)
-
-    @on_trait_change('input_slots_type,output_slots_type,'
-                     'input_slots_size,output_slots_size')
-    def update_slots(self):
-        self.changes_slots = True
-
-
-class ProbeKPICalculatorFactory(BaseKPICalculatorFactory,
-                                ProbeEvaluatorFactory):
-    id = Str(factory_id("enthought", "test_kpic"))
-    name = Str('test_kpi_calculator')
-
-    model_class = Type(ProbeKPICalculatorModel)
-
-    def create_model(self, model_data=None):
-        if model_data is None:
-            model_data = {}
-        return self.model_class(
-            factory=self,
-            input_slots_type=self.input_slots_type,
-            output_slots_type=self.output_slots_type,
-            input_slots_size=self.input_slots_size,
-            output_slots_size=self.output_slots_size,
-            **model_data
-        )
-
-    def create_kpi_calculator(self):
-        return ProbeKPICalculator(
-            factory=self,
-            run_function=self.run_function,
-        )

force_bdss/tests/test_core_evaluation_driver.py

@@ -9,8 +9,6 @@ from force_bdss.tests.probe_classes.factory_registry_plugin import \
     ProbeFactoryRegistryPlugin
 from force_bdss.tests.probe_classes.mco import ProbeMCOFactory
 from force_bdss.tests.probe_classes.data_source import ProbeDataSourceFactory
-from force_bdss.tests.probe_classes.kpi_calculator import (
-    ProbeKPICalculatorFactory)
 
 from force_bdss.core.input_slot_info import InputSlotInfo
 from force_bdss.core.data_value import DataValue
@@ -104,51 +102,6 @@ class TestCoreEvaluationDriver(unittest.TestCase):
                     " the number of user-defined names"):
                 driver.application_started()
 
-    def test_error_for_incorrect_kpic_output_slots(self):
-        kpi_calculator_factories = \
-            self.factory_registry_plugin.kpi_calculator_factories
-
-        def run(self, *args, **kwargs):
-            return [DataValue()]
-        kpi_calculator_factories[0] = ProbeKPICalculatorFactory(
-            None,
-            run_function=run)
-        driver = CoreEvaluationDriver(
-            application=self.mock_application,
-        )
-        with testfixtures.LogCapture():
-            with six.assertRaisesRegex(
-                    self,
-                    RuntimeError,
-                    "The number of data values \(1 values\)"
-                    " returned by 'test_kpi_calculator' does not match"
-                    " the number of output slots"):
-
-                driver.application_started()
-
-    def test_error_for_missing_kpic_output_names(self):
-        kpi_calculator_factories = \
-            self.factory_registry_plugin.kpi_calculator_factories
-
-        def run(self, *args, **kwargs):
-            return [DataValue()]
-        kpi_calculator_factories[0] = ProbeKPICalculatorFactory(
-            None,
-            run_function=run,
-            output_slots_size=1)
-        driver = CoreEvaluationDriver(
-            application=self.mock_application,
-        )
-
-        with testfixtures.LogCapture():
-            with six.assertRaisesRegex(
-                    self,
-                    RuntimeError,
-                    "The number of data values \(1 values\)"
-                    " returned by 'test_kpi_calculator' does not match"
-                    " the number of user-defined names"):
-                driver.application_started()
-
     def test_bind_data_values(self):
         data_values = [
             DataValue(name="foo"),
@@ -227,7 +180,6 @@ class TestCoreEvaluationDriver(unittest.TestCase):
         res = _compute_layer_results(
             data_values,
             [evaluator_model],
-            "create_data_source"
         )
         self.assertEqual(len(res), 2)
         self.assertEqual(res[0].name, "one")
@@ -243,10 +195,10 @@ class TestCoreEvaluationDriver(unittest.TestCase):
         #                    res3
         # layer 2:        res3 * res1
         #                     res4
-        # kpi layer:      res4 * res2
-        #
+        # layer 3:        res4 * res2
+        #                     out1
         # Final result should be
-        # ((in1 + in2 + in3 + in4) * (in1 + in2) * (in3 + in4)
+        # out1 = ((in1 + in2 + in3 + in4) * (in1 + in2) * (in3 + in4)
 
         data_values = [
             DataValue(value=10, name="in1"),
@@ -278,14 +230,9 @@ class TestCoreEvaluationDriver(unittest.TestCase):
             output_slots_size=1,
             run_function=multiplier)
 
-        multiplier_kpi_factory = ProbeKPICalculatorFactory(
-            None,
-            input_slots_size=2,
-            output_slots_size=1,
-            run_function=multiplier)
-
         wf = Workflow(
             execution_layers=[
+                [],
                 [],
                 [],
                 []
@@ -334,16 +281,16 @@ class TestCoreEvaluationDriver(unittest.TestCase):
         ]
         wf.execution_layers[2].append(model)
 
-        # KPI layer
-        model = multiplier_kpi_factory.create_model()
+        # layer 3
+        model = multiplier_factory.create_model()
         model.input_slot_info = [
             InputSlotInfo(name="res4"),
             InputSlotInfo(name="res2")
         ]
         model.output_slot_info = [
-            OutputSlotInfo(name="out1")
+            OutputSlotInfo(name="out1", is_kpi=True)
         ]
-        wf.kpi_calculators.append(model)
+        wf.execution_layers[3].append(model)
 
         kpi_results = execute_workflow(wf, data_values)
         self.assertEqual(len(kpi_results), 1)

force_bdss/tests/test_factory_registry_plugin.py

@@ -18,9 +18,7 @@ from envisage.application import Application
 
 from force_bdss.factory_registry_plugin import FactoryRegistryPlugin
 from force_bdss.data_sources.i_data_source_factory import IDataSourceFactory
-from force_bdss.kpi.i_kpi_calculator_factory import IKPICalculatorFactory
-from force_bdss.mco.i_mco_factory import \
-    IMCOFactory
+from force_bdss.mco.i_mco_factory import IMCOFactory
 
 
 class TestFactoryRegistry(unittest.TestCase):
@@ -33,7 +31,6 @@ class TestFactoryRegistry(unittest.TestCase):
     def test_initialization(self):
         self.assertEqual(self.plugin.mco_factories, [])
         self.assertEqual(self.plugin.data_source_factories, [])
-        self.assertEqual(self.plugin.kpi_calculator_factories, [])
 
 
 class MySuperPlugin(BaseExtensionPlugin):
@@ -56,14 +53,6 @@ class MySuperPlugin(BaseExtensionPlugin):
                 mock.Mock(spec=IDataSourceFactory,
                           id=factory_id("enthought", "ds2"))]
 
-    def _kpi_calculator_factories_default(self):
-        return [mock.Mock(spec=IKPICalculatorFactory,
-                          id=factory_id("enthought", "kpi1")),
-                mock.Mock(spec=IKPICalculatorFactory,
-                          id=factory_id("enthought", "kpi2")),
-                mock.Mock(spec=IKPICalculatorFactory,
-                          id=factory_id("enthought", "kpi3"))]
-
     def _notification_listener_factories_default(self):
         return [mock.Mock(spec=INotificationListenerFactory,
                           id=factory_id("enthought", "nl1"))]
@@ -81,7 +70,6 @@ class TestFactoryRegistryWithContent(unittest.TestCase):
     def test_initialization(self):
         self.assertEqual(len(self.plugin.mco_factories), 1)
         self.assertEqual(len(self.plugin.data_source_factories), 2)
-        self.assertEqual(len(self.plugin.kpi_calculator_factories), 3)
 
     def test_lookup(self):
         mco_id = factory_id("enthought", "mco1")
@@ -93,11 +81,6 @@ class TestFactoryRegistryWithContent(unittest.TestCase):
             id = factory_id("enthought", entry)
             self.assertEqual(self.plugin.data_source_factory_by_id(id).id, id)
 
-        for entry in ["kpi1", "kpi2", "kpi3"]:
-            id = factory_id("enthought", entry)
-            self.assertEqual(self.plugin.kpi_calculator_factory_by_id(id).id,
-                             id)
-
         for entry in ["nl1"]:
             id = factory_id("enthought", entry)
             self.assertEqual(
@@ -124,11 +107,6 @@ class TestFactoryRegistryWithContent(unittest.TestCase):
                 factory_id("enthought", "foo")
             )
 
-        with self.assertRaises(KeyError):
-            self.plugin.kpi_calculator_factory_by_id(
-                factory_id("enthought", "foo")
-            )
-
         with self.assertRaises(KeyError):
             self.plugin.notification_listener_factory_by_id(
                 factory_id("enthought", "foo")