pypushflow 0.1.0__tar.gz

home/payno/.local/share/virtualenvs/pypushflow_venv/lib/python3.7/site-packages/pypushflow/AbstractActor.py

@@ -0,0 +1,89 @@
+#
+# Copyright (c) European Synchrotron Radiation Facility (ESRF)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__authors__ = ["O. Svensson"]
+__license__ = "MIT"
+__date__ = "28/05/2019"
+
+import logging
+from pypushflow.addon import utils
+from pypushflow.addon.classes import BaseActorAddOn
+
+
+logger = logging.getLogger("pypushflow")
+
+
+class AbstractActor(object):
+    """
+    TODO
+    """
+
+    def __init__(self, parent=None, name=None):
+        if name is None:
+            raise RuntimeError("Actor name is None!")
+        self.name = name
+        self.listDownStreamActor = []
+        self.parent = parent
+        self.actorId = None
+
+        self._add_ons = []
+        for add_on_class in self._getAddOnsClasses():
+            self._add_ons.append(add_on_class())
+
+    def connect(self, actor):
+        logger.debug(
+            'Connecting actor "{0}" to actor "{1}"'.format(self.name, actor.name)
+        )
+        self.listDownStreamActor.append(actor)
+
+    def trigger(self, inData):
+        for actor in self.listDownStreamActor:
+            logger.debug(
+                'In actor "{0}", triggering actor "{1}"'.format(self.name, actor.name)
+            )
+            self._process_pre_trigger_add_on(inData)
+            actor.trigger(inData)
+            self._process_post_trigger_add_on()
+
+    def getActorPath(self):
+        return self.parent.getActorPath()
+
+    def get_addons(self):
+        """Return the list of add-on that will be apply to this actor"""
+        raise NotImplementedError()
+
+    def _process_post_trigger_add_on(self):
+        for add_on in self._add_ons:
+            add_on.post_trigger_action(actor=self)
+
+    def _process_pre_trigger_add_on(self, in_data):
+        for add_on in self._add_ons:
+            add_on.pre_trigger_action(actor=self, in_data=in_data)
+
+    def _getAddOnsClasses(self):
+        add_ons = []
+        for _, classes in utils.get_registered_add_ons_classes().items():
+            for class_ in classes:
+                import inspect
+
+                if BaseActorAddOn in (inspect.getmro(class_)):
+                    add_ons.append(class_)
+        return add_ons

home/payno/.local/share/virtualenvs/pypushflow_venv/lib/python3.7/site-packages/pypushflow/ErrorHandler.py

@@ -0,0 +1,38 @@
+#
+# Copyright (c) European Synchrotron Radiation Facility (ESRF)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__authors__ = ["O. Svensson"]
+__license__ = "MIT"
+__date__ = "28/05/2019"
+
+# from pypushflow import UtilsMongoDb
+
+from pypushflow.AbstractActor import AbstractActor
+
+
+class ErrorHandler(AbstractActor):
+    def __init__(self, parent=None, name="Error handler"):
+        AbstractActor.__init__(self, parent=parent, name=name)
+
+    def trigger(self, inData):
+        # if self.parent is not None and hasattr(self.parent, 'mongoId'):
+        #     UtilsMongoDb.setMongoStatus(self.parent.mongoId, 'error')
+        AbstractActor.trigger(self, inData=inData)

home/payno/.local/share/virtualenvs/pypushflow_venv/lib/python3.7/site-packages/pypushflow/ForkActor.py

@@ -0,0 +1,31 @@
+#
+# Copyright (c) European Synchrotron Radiation Facility (ESRF)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__authors__ = ["O. Svensson"]
+__license__ = "MIT"
+__date__ = "28/05/2019"
+
+from pypushflow.AbstractActor import AbstractActor
+
+
+class ForkActor(AbstractActor):
+    def __init__(self, parent=None, name="Fork actor"):
+        AbstractActor.__init__(self, parent=parent, name=name)

home/payno/.local/share/virtualenvs/pypushflow_venv/lib/python3.7/site-packages/pypushflow/JoinActor.py

@@ -0,0 +1,81 @@
+#
+# Copyright (c) European Synchrotron Radiation Facility (ESRF)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__authors__ = ["O. Svensson"]
+__license__ = "MIT"
+__date__ = "28/05/2019"
+
+from pypushflow.AbstractActor import AbstractActor
+
+
+class JoinActor(AbstractActor):
+    def __init__(self, parent=None, name="Join actor"):
+        AbstractActor.__init__(self, parent=parent, name=name)
+        self.numberOfThreads = 0
+        self.listInData = []
+
+    def increaseNumberOfThreads(self):
+        self.numberOfThreads += 1
+
+    def trigger(self, in_data):
+        if in_data is None:
+            channel = data = None
+        else:
+            channel, data = in_data
+        self.listInData.append(data)
+        if len(self.listInData) == self.numberOfThreads:
+            newInData = {}
+            for data in self.listInData:
+                newInData.update(data)
+            for actor in self.listDownStreamActor:
+                actor.trigger((channel, data))
+
+
+class JoinUntilStopSignal(AbstractActor):
+    def __init__(self, name):
+        self.name = name
+        self.listInData = []
+        self.listDownStreamActor = []
+        self._nprocess_received = 0
+        self._nprocess_waited = 0
+        self._can_stop = False
+
+    def connect(self, actor):
+        self.listDownStreamActor.append(actor)
+
+    def trigger(self, inData):
+        if (
+            type(inData) is dict
+            and "sig_type" in inData
+            and inData["sig_type"] == "stop"
+        ):
+            self._can_stop = True
+            self._nprocess_waited = inData["n_process"]
+        else:
+            self._nprocess_received += 1
+
+        self.listInData.append(inData)
+        if self._can_stop and self._nprocess_waited <= self._nprocess_received:
+            newInData = {}
+            for data in self.listInData:
+                newInData.update(data)
+            for actor in self.listDownStreamActor:
+                actor.trigger(newInData)

home/payno/.local/share/virtualenvs/pypushflow_venv/lib/python3.7/site-packages/pypushflow/PythonActor.py

@@ -0,0 +1,331 @@
+#
+# Copyright (c) European Synchrotron Radiation Facility (ESRF)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__authors__ = ["O. Svensson"]
+__license__ = "MIT"
+__date__ = "28/05/2019"
+
+import os
+import pprint
+import logging
+import traceback
+import functools
+import multiprocessing
+from multiprocessing.pool import Pool as _Pool
+from pypushflow.AbstractActor import AbstractActor
+from pypushflow.representation.scheme.node import Node
+
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowException(Exception):
+    def __init__(self, errorMessage="", traceBack="", data={}, msg=None):
+        super(WorkflowException, self).__init__(msg)
+        self.errorMessage = errorMessage
+        if data is None:
+            data = {}
+        self.data = data
+        self.traceBack = traceBack
+
+
+def trace_unhandled_exceptions(func):
+    @functools.wraps(func)
+    def wrapped_func(*args, **kwargs):
+        try:
+            out_data = func(*args, **kwargs)
+        except Exception as e:
+            errorMessage = "{0}".format(e)
+            logger.exception(errorMessage)
+            traceBack = traceback.format_exc()
+            return WorkflowException(
+                errorMessage=errorMessage, traceBack=traceBack, data=args[1]
+            )
+        return out_data
+
+    return wrapped_func
+
+
+#############################################################################
+# Create no daemon processes
+# See : https://stackoverflow.com/a/8963618
+#
+
+
+class NoDaemonProcess(multiprocessing.Process):
+    # make 'daemon' attribute always return False
+    def _get_daemon(self):
+        return False
+
+    def _set_daemon(self, value):
+        pass
+
+    daemon = property(_get_daemon, _set_daemon)
+
+
+# We sub-class multiprocessing.pool.Pool instead of multiprocessing.Pool
+# because the latter is only a wrapper function, not a proper class.
+
+
+class Pool(_Pool):
+    Process = NoDaemonProcess
+
+
+#
+#
+#############################################################################
+
+
+@trace_unhandled_exceptions
+def _exec_node(name: str, channel_name: str, data: dict, properties: dict):
+    """
+    Execute a node from the name of the process, input of the process and
+    properties of the process
+
+    :param str name: full name of the process to execute
+    :param data: data to process
+    :param properties: process properties / settings
+    :return: result of Node.execute
+    """
+    logger.debug(
+        "processing {0} on channel {1} with input {2} and {3} as "
+        "properties".format(str(name), str(channel_name), str(data), str(properties))
+    )
+    return Node.execute(
+        process_pt=name, properties=properties, input_data=data, input_name=channel_name
+    )
+
+
+class AsyncFactory:
+    """
+    TODO
+    """
+
+    def __init__(self, node, callback=None, errorCallback=None):
+        self.node = node
+        self.callback = callback
+        self.errorCallback = errorCallback
+        self.pool = Pool(1)
+
+    def call(self, *args, **kwargs):
+        logger.debug(
+            "Before apply_async, func={0}, callback={1}, errorCallback={2}".format(
+                self.node, self.callback, self.errorCallback
+            )
+        )
+        logger.debug("args={0}, kwargs={1}".format(args, kwargs))
+        if self.callback is None:
+            self.pool.apply_async(_exec_node, args, kwargs)
+        elif self.errorCallback is None:
+            self.pool.apply_async(_exec_node, args, kwargs, self.callback)
+        else:
+            self.pool.apply_async(
+                _exec_node, args, kwargs, self.callback, self.errorCallback
+            )
+        logger.debug("After apply_async")
+
+    def wait(self):
+        self.pool.close()
+        self.pool.join()
+
+
+class ActorWrapper(object):
+    """
+    TODO
+    """
+
+    def __init__(self, node):
+        self.node = node
+
+    @trace_unhandled_exceptions
+    def run(self, in_data):
+        logger.debug("In actor wrapper for {node}".format(node=self.node))
+        output_channel_name, out_data = self.node.execute(in_data)
+        if isinstance(out_data, WorkflowException):
+            return output_channel_name, out_data
+        else:
+            in_data.update(out_data)
+            return output_channel_name, out_data
+
+
+class PythonActor(AbstractActor):
+    """
+    TODO
+
+    * find a way to avoid 'duplication' of input 'script/process_pt'
+      (should be done upstream)
+    * I don't think script should have a default value.
+
+    :param parent:
+    :param name:
+    :param errorHandler:
+    :param script: script originally used
+    :param node: Node from representation
+
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        name="Python Actor",
+        errorHandler=None,
+        script=None,
+        node=None,
+    ):
+        if node is not None:
+            if script is not None:
+                raise ValueError(
+                    "if a process pointer is provided, you "
+                    "shouldn't provide a script"
+                )
+        elif script is None:
+            raise ValueError("no script provide to the python actor")
+
+        AbstractActor.__init__(self, parent=parent, name=name)
+        self.error_handler = errorHandler
+        self.list_error_handler = []
+        # Import script
+        self.script = script
+        if script is not None:
+            # module = importlib.import_module(os.path.splitext(script)[0])
+            if script.endswith(".py"):
+                script = "".join(os.path.splitext(script)[:-1])
+            node = Node(".".join((script, "run")))
+            self.actor_wrapper = ActorWrapper(node=node)
+        else:
+            self.actor_wrapper = ActorWrapper(node=node)
+
+        self.in_data = None
+        self.out_data = None
+        self.async_factory = None
+
+    def get_input_channel_name(self, type_):
+        return self.actor_wrapper.node.get_input_channel_name(type_)
+
+    def get_output_channel_name(self, type_):
+        return self.actor_wrapper.node.get_output_channel_name(type_)
+
+    def connectOnError(self, errorHandler):
+        self.list_error_handler.append(errorHandler)
+
+    def trigger(self, in_data):
+        """
+        'callback' function when this function is triggered.
+
+        :param data: input data
+        """
+        channel, in_data = in_data
+        logging.info("On trigger channel is " + str(channel))
+        # cast data to dict if necessary
+        if hasattr(in_data, "to_dict"):
+            in_data = in_data.to_dict()
+
+        self.in_data = in_data
+        logger.debug(
+            "In trigger {0}, inData = {1}".format(self.name, pprint.pformat(in_data))
+        )
+        if isinstance(in_data, WorkflowException):
+            logger.error(
+                "Error from previous actor! Not running actor {0}".format(self.name)
+            )
+            if self.error_handler is not None:
+                workflowException = in_data
+                oldInData = workflowException.data
+                exceptionDict = {
+                    "errorMessage": workflowException.errorMessage,
+                    "traceBack": workflowException.traceBack.split("\n"),
+                }
+                oldInData["WorkflowException"] = exceptionDict
+                self.triggerOnError(oldInData)
+
+        self.async_factory = AsyncFactory(
+            self.actor_wrapper.run,
+            callback=self.triggerDownStreamActor,
+            errorCallback=self.error_handler,
+        )
+        self.async_factory.call(
+            self.actor_wrapper.node.process_pt,
+            channel,
+            in_data,
+            self.actor_wrapper.node.properties,
+        )
+
+    def errorHandler(self, exception):
+        logger.error("Error when running actor {0}!".format(self.name))
+        workflowException = WorkflowException(
+            errorMessage=exception, traceBack=None, data=None
+        )
+        inData = {"WorkflowException": workflowException}
+        logger.error(exception)
+        for errorHandler in self.list_error_handler:
+            errorHandler.trigger(inData)
+        if self.error_handler is not None:
+            self.error_handler.triggerOnError(inData)
+
+    def triggerDownStreamActor(self, output_last_processing=(None, {})):
+        logging.warning("---------------------")
+        logging.warning(output_last_processing)
+        logging.warning("---------------------")
+        try:
+            output_channel, inData = output_last_processing
+        except TypeError:
+            output_channel, inData = None, output_last_processing
+        logger.info(
+            "In triggerDownStreamActor for {0}, Output channel is {1}, "
+            "inData is {2}".format(self.name, output_channel, inData)
+        )
+        if isinstance(inData, WorkflowException):
+            logger.error(
+                "Error from previous actor! Not running down stream actors {0}".format(
+                    [actor.name for actor in self.listDownStreamActor]
+                )
+            )
+            workflowException = inData
+            oldInData = workflowException.data
+            exceptionDict = {
+                "errorMessage": workflowException.errorMessage,
+                "traceBack": workflowException.traceBack.split("\n"),
+            }
+            logger.warning(
+                "oldInData type: {}, value: {}".format(type(oldInData), oldInData)
+            )
+            oldInData["WorkflowException"] = exceptionDict
+            for errorHandler in self.list_error_handler:
+                errorHandler.trigger((None, oldInData))
+            if self.error_handler is not None:
+                logger.error(
+                    'Trigger on error on errorHandler "{0}"'.format(
+                        self.error_handler.name
+                    )
+                )
+                self.error_handler.triggerOnError(inData=(None, oldInData))
+        else:
+            out_data = {}
+            if inData is not None:
+                for key, value in inData.items():
+                    if key in self.in_data:
+                        if self.in_data[key] != value:
+                            out_data[key] = value
+                    else:
+                        out_data[key] = value
+
+            for downStreamActor in self.listDownStreamActor:
+                downStreamActor.trigger((output_channel, inData))

home/payno/.local/share/virtualenvs/pypushflow_venv/lib/python3.7/site-packages/pypushflow/RequestStatus.py

@@ -0,0 +1,31 @@
+#
+# Copyright (c) European Synchrotron Radiation Facility (ESRF)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__authors__ = ["O. Svensson"]
+__license__ = "MIT"
+__date__ = "28/05/2019"
+
+from pypushflow.AbstractActor import AbstractActor
+
+
+class RequestStatus(AbstractActor):
+    def __init__(self, parent, name="Request status"):
+        AbstractActor.__init__(self, parent=parent, name=name)

home/payno/.local/share/virtualenvs/pypushflow_venv/lib/python3.7/site-packages/pypushflow/RouterActor.py

@@ -0,0 +1,87 @@
+#
+# Copyright (c) European Synchrotron Radiation Facility (ESRF)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__authors__ = ["O. Svensson"]
+__license__ = "MIT"
+__date__ = "28/05/2019"
+
+from pypushflow.AbstractActor import AbstractActor
+
+import logging
+
+logger = logging.getLogger("pypushflow")
+
+
+class RouterActor(AbstractActor):
+    def __init__(
+        self, parent, errorHandler=None, name="Router", itemName=None, listPort=[]
+    ):
+        AbstractActor.__init__(self, parent, name)
+        self.errorHandler = errorHandler
+        self.name = name
+        self.itemName = itemName
+        self.listPort = listPort
+        self.dictValues = {}
+
+    def connect(self, actor, expectedValue="other"):
+        if expectedValue != "other" and not expectedValue in self.listPort:
+            raise RuntimeError(
+                "Port {0} not defined for router actor {1}!".format(
+                    expectedValue, self.name
+                )
+            )
+        if expectedValue in self.dictValues:
+            self.dictValues[expectedValue].append(actor)
+        else:
+            self.dictValues[expectedValue] = [actor]
+
+    def trigger(self, inData):
+        logger.debug('In router actor "{0}"'.format(self.name))
+        listActor = None
+        if self.itemName in inData and not inData[self.itemName] in [
+            None,
+            "None",
+            "null",
+        ]:
+            logger.debug(
+                'In router actor "{0}", itemName {1} in inData'.format(
+                    self.name, self.itemName
+                )
+            )
+            value = inData[self.itemName]
+            logger.debug('In router actor "{0}", value = {1}'.format(self.name, value))
+            if not isinstance(value, dict) and value in self.dictValues:
+                listActor = self.dictValues[value]
+        if listActor is None:
+            logger.debug('In router actor "{0}", actor is None')
+            if "other" in self.dictValues:
+                listActor = self.dictValues["other"]
+            else:
+                raise RuntimeError(
+                    'No "other" port for router actor "{0}"'.format(self.name)
+                )
+        for actor in listActor:
+            logger.debug(
+                'In router actor "{0}", triggering actor "{1}"'.format(
+                    self.name, actor.name
+                )
+            )
+            actor.trigger(inData)