Input output addition

examples/test_csv.json

 {
   "multi_criteria_optimizer": {
     "name": "dakota",
-    "model_data": {}
+    "model_data": {
+      "value_types": ["DUMMY"]
+    }
   },
   "data_sources": [
     {

force_bdss/core_mco_driver.py

@@ -41,68 +41,63 @@ class CoreMCODriver(Plugin):
     @on_trait_change("application:started")
     def application_started(self):
         workflow = self.application.workflow
-        if self.application.evaluate:
-            ds_results = []
-            for requested_ds in workflow.data_sources:
-                ds_bundle = self._find_data_source_bundle_by_name(
-                    requested_ds.name)
-                if ds_bundle:
-                    ds_model = ds_bundle.create_model(requested_ds.model_data)
-                    data_source = ds_bundle.create_data_source(
-                        self.application, ds_model)
-                    ds_results.append(data_source.run())
-                else:
-                    raise Exception("Requested data source {} but don't know "
-                                    "to find it.".format(requested_ds.name))
-
-            kpi_results = []
-            for requested_kpic in workflow.kpi_calculators:
-                kpic_bundle = self._find_kpi_calculator_bundle_by_name(
-                    requested_kpic.name)
-                if kpic_bundle:
-                    ds_model = kpic_bundle.create_model(
-                        requested_kpic.model_data)
-                    kpi_calculator = kpic_bundle.create_data_source(
-                        self.application, ds_model)
-                    kpi_results.append(kpi_calculator.run(ds_results))
-                else:
-                    raise Exception(
-                        "Requested kpi calculator {} but don't know "
-                        "to find it.".format(requested_kpic.name))
-
-                print(
-                    kpi_results[0].value_types,
-                    kpi_results[0].values
-                )
-
-        else:
-            mco_data = workflow.multi_criteria_optimizer
-            mco_bundle = self._find_mco_bundle_by_name(mco_data.name)
-            if mco_bundle:
-                mco_model = mco_bundle.create_model(mco_data.model_data)
-                mco = mco_bundle.create_optimizer(self.application, mco_model)
-                mco.run()
-            else:
-                raise Exception("Requested MCO {} but it's not available"
-                                "to compute it.".format(mco_data.name))
-
-    def _find_data_source_bundle_by_name(self, name):
+
+        mco_data = workflow.multi_criteria_optimizer
+        mco_bundle = self._mco_bundle_by_name(mco_data.name)
+        mco_model = mco_bundle.create_model(mco_data.model_data)
+        mco = mco_bundle.create_optimizer(self.application, mco_model)
+        mco_communicator = mco_bundle.create_communicator(
+            self.application,
+            mco_model)
+
+        if not self.application.evaluate:
+            mco.run()
+            return
+
+        parameters = mco_communicator.receive_from_mco()
+
+        ds_results = []
+        for requested_ds in workflow.data_sources:
+            ds_bundle = self._data_source_bundle_by_name(
+                requested_ds.name)
+            ds_model = ds_bundle.create_model(requested_ds.model_data)
+            data_source = ds_bundle.create_data_source(
+                self.application, ds_model)
+            ds_results.append(data_source.run(parameters))
+
+        kpi_results = []
+        for requested_kpic in workflow.kpi_calculators:
+            kpic_bundle = self._kpi_calculator_bundle_by_name(
+                requested_kpic.name)
+            ds_model = kpic_bundle.create_model(
+                requested_kpic.model_data)
+            kpi_calculator = kpic_bundle.create_data_source(
+                self.application, ds_model)
+            kpi_results.append(kpi_calculator.run(ds_results))
+
+        mco_communicator.send_to_mco(kpi_results)
+
+    def _data_source_bundle_by_name(self, name):
         for ds in self.data_source_bundles:
             if ds.name == name:
                 return ds
 
-        return None
+        raise Exception("Requested data source {} but don't know "
+                        "to find it.".format(name))
 
-    def _find_kpi_calculator_bundle_by_name(self, name):
+    def _kpi_calculator_bundle_by_name(self, name):
         for kpic in self.kpi_calculator_bundles:
             if kpic.name == name:
                 return kpic
 
-        return None
+        raise Exception(
+            "Requested kpi calculator {} but don't know "
+            "to find it.".format(name))
 
-    def _find_mco_bundle_by_name(self, name):
+    def _mco_bundle_by_name(self, name):
         for mco in self.mco_bundles:
             if mco.name == name:
                 return mco
 
-        return None
+        raise Exception("Requested MCO {} but it's not available"
+                        "to compute it.".format(mco_data.name))

force_bdss/core_plugins/csv_extractor/csv_extractor/csv_extractor_data_source.py

@@ -5,7 +5,7 @@ from force_bdss.data_sources.data_source_result import DataSourceResult
 
 
 class CSVExtractorDataSource(BaseDataSource):
-    def run(self):
+    def run(self, parameters):
         with open(self.model.filename) as csvfile:
             reader = csv.reader(csvfile)
             for rowindex, row in enumerate(reader):
@@ -17,7 +17,8 @@ class CSVExtractorDataSource(BaseDataSource):
                         originator=self,
                         value_types = [self.model.cuba_type],
                         values=numpy.array(
-                            float(row[self.model.column])).reshape(1,1)
+                            parameters.values[0]+float(
+                                row[self.model.column])).reshape(1,1)
                     )
 
                 return None

force_bdss/core_plugins/test_mco/dakota/dakota_bundle.py

 from traits.has_traits import HasStrictTraits, provides
 from traits.trait_types import String
 
+from force_bdss.core_plugins.test_mco.dakota.dakota_communicator import \
+    DakotaCommunicator
 from force_bdss.mco.i_multi_criteria_optimizer_bundle import (
     IMultiCriteriaOptimizerBundle)
 
@@ -17,3 +19,6 @@ class DakotaBundle(HasStrictTraits):
 
     def create_optimizer(self, application, model):
         return DakotaOptimizer(self, application, model)
+
+    def create_communicator(self, application, model):
+        return DakotaCommunicator(self, application, model)

force_bdss/core_plugins/test_mco/dakota/dakota_communicator.py

+import sys
+import numpy
+
+from force_bdss.data_sources.data_source_parameters import DataSourceParameters
+from force_bdss.mco.base_mco_communicator import BaseMCOCommunicator
+
+
+class DakotaCommunicator(BaseMCOCommunicator):
+    def receive_from_mco(self):
+        data = sys.stdin.read()
+        values = list(map(float, data.split()))
+        value_types = self.model.value_types
+        if len(values) != len(value_types):
+            raise ValueError("Length of provided data differs from the number "
+                             "of expected types. {} {}".format(values,
+                                                               value_types))
+
+        return DataSourceParameters(
+            value_types=value_types,
+            values=numpy.array(values)
+        )
+
+    def send_to_mco(self, kpi_results):
+        data = " ".join(
+            [" ".join(list(map(str, r.values.tolist()))) for r in kpi_results]
+        )
+        sys.stdout.write(data)

force_bdss/core_plugins/test_mco/dakota/dakota_model.py

-from traits.api import HasStrictTraits
+from traits.api import HasStrictTraits, List, String
 
 
 class DakotaModel(HasStrictTraits):
+    value_types = List(String)
+
     @classmethod
     def from_json(cls, model_data):
-        return cls()
+        return cls(value_types=model_data["value_types"])

force_bdss/core_plugins/test_mco/dakota/dakota_optimizer.py

@@ -10,5 +10,13 @@ from force_bdss.mco.base_multi_criteria_optimizer import (
 class DakotaOptimizer(BaseMultiCriteriaOptimizer):
     def run(self):
         print("Running dakota optimizer")
-        subprocess.check_call([sys.argv[0], "--evaluate",
-                               self.application.workflow_filepath])
+        for initial_value in range(10):
+            ps = subprocess.Popen(
+                [sys.argv[0],
+                 "--evaluate",
+                 self.application.workflow_filepath],
+                stdout=subprocess.PIPE,
+                stdin=subprocess.PIPE)
+
+            out = ps.communicate("{}".format(initial_value).encode("utf-8"))
+            print("{}: {}".format(initial_value, out[0].decode("utf-8")))

force_bdss/data_sources/base_data_source.py

@@ -13,7 +13,7 @@ class BaseDataSource(six.with_metaclass(abc.ABCMeta)):
         return self.bundle.name
 
     @abc.abstractmethod
-    def run(self):
+    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/data_source_parameters.py

+from traits.api import HasStrictTraits, Array, List, String
+
+
+class DataSourceParameters(HasStrictTraits):
+    value_types = List(String)
+    values = Array(shape=(None,))

force_bdss/mco/base_mco_communicator.py

+import abc
+import six
+
+
+class BaseMCOCommunicator(six.with_metaclass(abc.ABCMeta)):
+    def __init__(self, bundle, application, model):
+        self.bundle = bundle
+        self.application = application
+        self.model = model
+
+    @abc.abstractmethod
+    def receive_from_mco(self):
+        pass
+
+    @abc.abstractmethod
+    def send_to_mco(self):
+        pass

force_bdss/mco/i_multi_criteria_optimizer_bundle.py

@@ -9,3 +9,6 @@ class IMultiCriteriaOptimizerBundle(Interface):
 
     def create_model(self, model_data):
         pass
+
+    def create_communicator(self, model_data):
+        pass