Merge pull request #34 from force-h2020/30-base-data-source-hastraits

Using ABCHasStrictTraits for the Base classes and enforce traits compliancy

force_bdss/data_sources/base_data_source.py

+from traits.api import ABCHasStrictTraits, Instance
 import abc
-import six
 
+from .base_data_source_model import BaseDataSourceModel
+from ..bdss_application import BDSSApplication
+from ..data_sources.i_data_source_bundle import IDataSourceBundle
 
-class BaseDataSource(six.with_metaclass(abc.ABCMeta)):
+
+class BaseDataSource(ABCHasStrictTraits):
     """Base class for the DataSource, any computational engine/retriever
     for data.
 
     Inherit from this class for your specific DataSource.
     """
-    def __init__(self, bundle, application, model):
+    #: A reference to the bundle
+    bundle = Instance(IDataSourceBundle)
+    #: A reference to the application
+    application = Instance(BDSSApplication)
+    #: A reference to the model class
+    model = Instance(BaseDataSourceModel)
+
+    def __init__(self, bundle, application, model, *args, **kwargs):
         self.bundle = bundle
         self.application = application
         self.model = model
+        super(BaseDataSource, self).__init__(*args, **kwargs)
 
     @property
     def name(self):
+        """Utility property to retrieve the bundle name from the data source
+        object."""
         return self.bundle.name
 
     @abc.abstractmethod
     def run(self, parameters):
         """Executes the data source evaluation/fetching and returns
         the list of results as a DataSourceResult instance."""
-        pass

force_bdss/data_sources/tests/test_base_data_source.py

+import unittest
+
+from force_bdss.data_sources.base_data_source import BaseDataSource
+from force_bdss.data_sources.base_data_source_model import BaseDataSourceModel
+from force_bdss.data_sources.i_data_source_bundle import IDataSourceBundle
+
+try:
+    import mock
+except ImportError:
+    from unittest import mock
+
+from force_bdss.bdss_application import BDSSApplication
+
+
+class DummyDataSource(BaseDataSource):
+    def run(self, *args, **kwargs):
+        pass
+
+
+class TestBaseDataSource(unittest.TestCase):
+    def test_initialization(self):
+        bundle = mock.Mock(spec=IDataSourceBundle)
+        application = mock.Mock(spec=BDSSApplication)
+        model = mock.Mock(spec=BaseDataSourceModel)
+        ds = DummyDataSource(bundle, application, model)
+
+        self.assertEqual(ds.bundle, bundle)
+        self.assertEqual(ds.application, application)
+        self.assertEqual(ds.model, model)

force_bdss/kpi/base_kpi_calculator.py

 import abc
-import six
 
+from traits.api import ABCHasStrictTraits, Instance
 
-class BaseKPICalculator(six.with_metaclass(abc.ABCMeta)):
-    def __init__(self, bundle, application, model):
+from ..bdss_application import BDSSApplication
+from .base_kpi_calculator_model import BaseKPICalculatorModel
+from .i_kpi_calculator_bundle import IKPICalculatorBundle
+
+
+class BaseKPICalculator(ABCHasStrictTraits):
+    """Base class for the KPICalculators.
+
+    Inherit this class for your KPI calculator.
+    """
+    #: A reference to the bundle
+    bundle = Instance(IKPICalculatorBundle)
+    #: A reference to the application
+    application = Instance(BDSSApplication)
+    #: A reference to the model class
+    model = Instance(BaseKPICalculatorModel)
+
+    def __init__(self, bundle, application, model, *args, **kwargs):
         self.bundle = bundle
         self.application = application
         self.model = model
+        super(BaseKPICalculator, self).__init__(*args, **kwargs)
 
     @property
     def name(self):
+        """Convenience property. Returns the name of the originating bundle."""
         return self.bundle.name
 
     @abc.abstractmethod
     def run(self, data_source_results):
-        """Executes the KPI evaluation and returns the list of results."""
-        pass
+        """
+        Executes the KPI evaluation and returns the list of results.
+        Reimplement this method in your specific KPI calculator.
+
+        Parameters
+        ----------
+        data_source_results:
+            a list of DataSourceResult instances containing the results of the
+            evaluation.
+        """

force_bdss/kpi/tests/test_base_kpi_calculator.py

+import unittest
+try:
+    import mock
+except ImportError:
+    from unittest import mock
+
+from force_bdss.bdss_application import BDSSApplication
+from force_bdss.kpi.base_kpi_calculator_model import BaseKPICalculatorModel
+from force_bdss.kpi.base_kpi_calculator import BaseKPICalculator
+from force_bdss.kpi.i_kpi_calculator_bundle import IKPICalculatorBundle
+
+
+class DummyKPICalculator(BaseKPICalculator):
+    def run(self, *args, **kwargs):
+        pass
+
+
+class TestBaseKPICalculator(unittest.TestCase):
+    def test_initialization(self):
+        bundle = mock.Mock(spec=IKPICalculatorBundle)
+        application = mock.Mock(spec=BDSSApplication)
+        model = mock.Mock(spec=BaseKPICalculatorModel)
+        kpic = DummyKPICalculator(bundle, application, model)
+
+        self.assertEqual(kpic.bundle, bundle)
+        self.assertEqual(kpic.application, application)
+        self.assertEqual(kpic.model, model)

force_bdss/mco/base_multi_criteria_optimizer.py

 import abc
-import six
 
+from traits.api import ABCHasStrictTraits, Instance
 
-class BaseMultiCriteriaOptimizer(six.with_metaclass(abc.ABCMeta)):
-    def __init__(self, bundle, application, model):
+from ..bdss_application import BDSSApplication
+from .base_mco_model import BaseMCOModel
+from .i_multi_criteria_optimizer_bundle import IMultiCriteriaOptimizerBundle
+
+
+class BaseMultiCriteriaOptimizer(ABCHasStrictTraits):
+    """Base class for the Multi Criteria Optimizer.
+
+    Inherit this class for your MCO implementation
+    """
+    #: A reference to the bundle
+    bundle = Instance(IMultiCriteriaOptimizerBundle)
+    #: A reference to the application
+    application = Instance(BDSSApplication)
+    #: A reference to the model class
+    model = Instance(BaseMCOModel)
+
+    def __init__(self, bundle, application, model, *args, **kwargs):
         self.bundle = bundle
         self.application = application
         self.model = model
+        super(BaseMultiCriteriaOptimizer, self).__init__(*args, **kwargs)
 
     @property
     def name(self):
+        """Convenience property to return the name of the bundle from the
+        MCO itself"""
         return self.bundle.name
 
     @abc.abstractmethod
     def run(self):
+        """Reimplement this method to perform the MCO operations."""
         pass

force_bdss/mco/tests/test_base_multi_criteria_optimizer.py

+import unittest
+
+from force_bdss.mco.base_mco_model import BaseMCOModel
+from force_bdss.mco.base_multi_criteria_optimizer import \
+    BaseMultiCriteriaOptimizer
+from force_bdss.mco.i_multi_criteria_optimizer_bundle import \
+    IMultiCriteriaOptimizerBundle
+
+try:
+    import mock
+except ImportError:
+    from unittest import mock
+
+from force_bdss.bdss_application import BDSSApplication
+
+
+class DummyMCO(BaseMultiCriteriaOptimizer):
+    def run(self, *args, **kwargs):
+        pass
+
+
+class TestBaseKPICalculator(unittest.TestCase):
+    def test_initialization(self):
+        bundle = mock.Mock(spec=IMultiCriteriaOptimizerBundle)
+        application = mock.Mock(spec=BDSSApplication)
+        model = mock.Mock(spec=BaseMCOModel)
+        mco = DummyMCO(bundle, application, model)
+
+        self.assertEqual(mco.bundle, bundle)
+        self.assertEqual(mco.application, application)
+        self.assertEqual(mco.model, model)