Working implementation

force_bdss/api.py

@@ -20,3 +20,8 @@ from .mco.i_mco_factory import IMCOFactory  # noqa
 
 from .mco.parameters.base_mco_parameter_factory import BaseMCOParameterFactory  # noqa
 from .mco.parameters.base_mco_parameter import BaseMCOParameter  # noqa
+
+from .notification_listeners.i_notification_listener_factory import INotificationListenerFactory  # noqa
+from .notification_listeners.base_notification_listener import BaseNotificationListener  # noqa
+from .notification_listeners.base_notification_listener_factory import BaseNotificationListenerFactory  # noqa
+from .notification_listeners.base_notification_listener_model import BaseNotificationListenerModel  # noqa

force_bdss/base_extension_plugin.py

 from envisage.plugin import Plugin
 from traits.trait_types import List
 
+from .notification_listeners.i_notification_listener_factory import \
+    INotificationListenerFactory
 from .ids import ExtensionPointID
 from .data_sources.i_data_source_factory import IDataSourceFactory
 from .kpi.i_kpi_calculator_factory import IKPICalculatorFactory
@@ -40,7 +42,7 @@ class BaseExtensionPlugin(Plugin):
         contributes_to=ExtensionPointID.KPI_CALCULATOR_FACTORIES
     )
 
-    notifier_factory = List(
-        INotifierFactory,
-        contributes_to=ExtensionPointID.NOTIFIER_FACTORIES
+    notification_listener_factories = List(
+        INotificationListenerFactory,
+        contributes_to=ExtensionPointID.NOTIFICATION_LISTENER_FACTORIES
     )

force_bdss/core_mco_driver.py

@@ -2,9 +2,11 @@ from __future__ import print_function
 
 import sys
 
-from traits.api import on_trait_change, Instance
+from traits.api import on_trait_change, Instance, List
 
 from force_bdss.mco.base_mco import BaseMCO
+from force_bdss.notification_listeners.base_notification_listener import \
+    BaseNotificationListener
 from .ids import plugin_id
 from .base_core_driver import BaseCoreDriver
 from .io.workflow_reader import (
@@ -23,10 +25,13 @@ class CoreMCODriver(BaseCoreDriver):
 
     mco = Instance(BaseMCO, allow_none=True)
 
-    listeners = Instance(BaseNotificationListener)
+    listeners = List(Instance(BaseNotificationListener))
 
     @on_trait_change("application:started")
     def application_started(self):
+        self.mco.run(self.workflow.mco)
+
+    def _mco_default(self):
         try:
             workflow = self.workflow
         except (InvalidVersionException, InvalidFileException) as e:
@@ -35,5 +40,26 @@ class CoreMCODriver(BaseCoreDriver):
 
         mco_model = workflow.mco
         mco_factory = mco_model.factory
-        mco = mco_factory.create_optimizer()
-        mco.run(mco_model)
+        return mco_factory.create_optimizer()
+
+    @on_trait_change("mco:started,mco:finished,mco:progress")
+    def _handle_mco_event(self, object, name, old, new):
+        if name == "started":
+            self._deliver_to_listeners("MCO_STARTED")
+        elif name == "finished":
+            self._deliver_to_listeners("MCO_FINISHED")
+        elif name == "progress":
+            self._deliver_to_listeners("MCO_PROGRESS")
+
+    def _deliver_to_listeners(self, message):
+        for listener in self.listeners:
+            listener.deliver(None, message)
+
+    def _listeners_default(self):
+        listeners = []
+
+        print(self.factory_registry.notification_listener_factories)
+        for factory in self.factory_registry.notification_listener_factories:
+            listeners.append(factory.create_listener())
+
+        return listeners

force_bdss/core_plugins/dummy/dummy_dakota/dakota_optimizer.py

@@ -16,6 +16,7 @@ def rotated_range(start, stop, starting_value):
 
 class DummyDakotaOptimizer(BaseMCO):
     def run(self, model):
+        self.started = True
         parameters = model.parameters
 
         values = []
@@ -42,3 +43,6 @@ class DummyDakotaOptimizer(BaseMCO):
                 " ".join([str(v) for v in value]).encode("utf-8"))
             print("{}: {}".format(" ".join([str(v) for v in value]),
                                   out[0].decode("utf-8")))
+            self.progress = True
+
+        self.finished = True

force_bdss/core_plugins/dummy/dummy_notification_listener/dummy_notification_listener.py

+from force_bdss.api import BaseNotificationListener
+
+
+class DummyNotificationListener(BaseNotificationListener):
+    def deliver(self, model, message):
+        print(message)

force_bdss/core_plugins/dummy/dummy_notification_listener/dummy_notification_listener_factory.py

+from traits.api import String
+
+from force_bdss.ids import factory_id
+from force_bdss.notification_listeners.base_notification_listener_factory \
+    import \
+    BaseNotificationListenerFactory
+from .dummy_notification_listener import DummyNotificationListener
+from .dummy_notification_listener_model import DummyNotificationListenerModel
+
+
+class DummyNotificationListenerFactory(BaseNotificationListenerFactory):
+    id = String(factory_id("enthought", "dummy_notification_listener"))
+
+    name = String("Dummy Notification Listener")
+
+    def create_model(self, model_data=None):
+        if model_data is None:
+            model_data = {}
+
+        return DummyNotificationListenerModel(self, **model_data)
+
+    def create_listener(self):
+        return DummyNotificationListener(self)

force_bdss/core_plugins/dummy/dummy_notification_listener/dummy_notification_listener_model.py

+from force_bdss.notification_listeners.base_notification_listener_model \
+    import \
+    BaseNotificationListenerModel
+
+
+class DummyNotificationListenerModel(BaseNotificationListenerModel):
+    pass

force_bdss/core_plugins/dummy/dummy_plugin.py

 from force_bdss.api import BaseExtensionPlugin, plugin_id
+from force_bdss.core_plugins.dummy.dummy_notification_listener\
+    .dummy_notification_listener_factory import \
+    DummyNotificationListenerFactory
 from .csv_extractor.csv_extractor_factory import CSVExtractorFactory
 from .kpi_adder.kpi_adder_factory import KPIAdderFactory
 from .dummy_dakota.dakota_factory import DummyDakotaFactory
@@ -23,4 +26,4 @@ class DummyPlugin(BaseExtensionPlugin):
                 KPIAdderFactory(self)]
 
     def _notification_listener_factories_default(self):
-        return [GUINotificationListenerFactory()]
+        return [DummyNotificationListenerFactory(self)]

force_bdss/notification_listeners/base_notification_listener.py

+import abc
+
+from traits.api import ABCHasStrictTraits, Instance
+
+from .i_notification_listener_factory import INotificationListenerFactory
+
+
+class BaseNotificationListener(ABCHasStrictTraits):
+    """Base class for the Multi Criteria Optimizer.
+
+    Inherit this class for your MCO implementation
+    """
+    #: A reference to the factory
+    factory = Instance(INotificationListenerFactory)
+
+    def __init__(self, factory, *args, **kwargs):
+        """Initializes the MCO.
+
+        Parameters
+        ----------
+        factory: BaseMCOFactory
+            The factory this BaseMCO belongs to
+        """
+        self.factory = factory
+        super(BaseNotificationListener, self).__init__(*args, **kwargs)
+
+    @abc.abstractmethod
+    def deliver(self, model, message):
+        pass

force_bdss/notification_listeners/base_notification_listener_factory.py

 import abc
 
-from traits.api import ABCHasStrictTraits, Instance, String, provides
+from traits.api import ABCHasStrictTraits, Instance, String, provides, Any
 from envisage.plugin import Plugin
 
 from .i_notification_listener_factory import INotificationListenerFactory
@@ -14,10 +14,26 @@ class BaseNotificationListenerFactory(ABCHasStrictTraits):
 
     plugin = Instance(Plugin)
 
+    persistent_state = Any()
+
+    def __init__(self, plugin, *args, **kwargs):
+        """Initializes the instance.
+
+        Parameters
+        ----------
+        plugin: Plugin
+            The plugin that holds this factory.
+        """
+        self.plugin = plugin
+        super(BaseNotificationListenerFactory, self).__init__(*args, **kwargs)
+
     @abc.abstractmethod
-    def create_object(self):
+    def create_listener(self):
         """"""
 
     @abc.abstractmethod
     def create_model(self, model_data=None):
         """"""
+
+    def init_persistent_state(self):
+        pass

force_bdss/notification_listeners/base_notification_listener_model.py

+from traits.api import ABCHasStrictTraits, Instance
+
+from force_bdss.notification_listeners.i_notification_listener_factory import \
+    INotificationListenerFactory
+
+
+class BaseNotificationListenerModel(ABCHasStrictTraits):
+    """Base class for the specific MCO models.
+    This model will also provide, through traits/traitsui magic the View
+    that will appear in the workflow manager UI.
+
+    In your definition, your specific model must reimplement this class.
+    """
+    #: A reference to the creating factory, so that we can
+    #: retrieve it as the originating factory.
+    factory = Instance(INotificationListenerFactory,
+                       visible=False,
+                       transient=True)
+
+    def __init__(self, factory, *args, **kwargs):
+        self.factory = factory
+        super(BaseNotificationListenerModel, self).__init__(*args, **kwargs)

force_bdss/notification_listeners/i_notification_listener_factory.py

-from traits.api import Interface, String, Instance
+from traits.api import Interface, String, Instance, Any
 from envisage.plugin import Plugin
 
 
@@ -14,8 +14,13 @@ class INotificationListenerFactory(Interface):
 
     plugin = Instance(Plugin)
 
-    def create_object(self):
+    persistent_state = Any
+
+    def create_listener(self):
         """"""
 
     def create_model(self, model_data=None):
         """"""
+
+    def init_persistent_state(self):
+        pass