ztl 0.0.1__tar.gz

ztl-0.0.1/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2023, UH Robot House / User Projects
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

ztl-0.0.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: ztl
+Version: 0.0.1
+Summary: A thin library relying on zmq to dispatch tasks
+Home-page: https://gitlab.com/robothouse/rh-user/ztl/
+Author: Patrick Holthaus
+Author-email: Patrick Holthaus <patrick.holthaus@googlemail.com>
+License: BSD 2-Clause License
+        
+        Copyright (c) 2023, UH Robot House / User Projects
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://gitlab.com/robothouse/rh-user/ztl/
+Project-URL: Bug Tracker, https://gitlab.com/robothouse/rh-user/ztl/issues/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: oyaml
+Requires-Dist: pyzmq
+Requires-Dist: pytest
+Requires-Dist: pytest-xprocess
+
+This project contains the `ZTL` library enabling light-weight and widely compatible **remote task execution** using [ZeroMQ](https://zeromq.org/).
+
+The basic communication principle is as follows:
+
+![communication overview](res/overview.png)
+
+Thereby, each task has the following lifecycle:
+
+![task lifecycle](res/task%20lifecycle.png)
+
+An example communication could look like this:
+
+Request:
+
+![communication overview](res/protocol.png)
+
+Reply:
+
+![communication overview](res/protocol%20reply.png)

ztl-0.0.1/README.md

@@ -0,0 +1,19 @@
+This project contains the `ZTL` library enabling light-weight and widely compatible **remote task execution** using [ZeroMQ](https://zeromq.org/).
+
+The basic communication principle is as follows:
+
+![communication overview](res/overview.png)
+
+Thereby, each task has the following lifecycle:
+
+![task lifecycle](res/task%20lifecycle.png)
+
+An example communication could look like this:
+
+Request:
+
+![communication overview](res/protocol.png)
+
+Reply:
+
+![communication overview](res/protocol%20reply.png)

ztl-0.0.1/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "ztl"
+version = "0.0.1"
+authors = [
+  { name="Patrick Holthaus", email="patrick.holthaus@googlemail.com" },
+]
+description = "A thin library relying on zmq to dispatch tasks"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "oyaml",
+    "pyzmq",
+    "pytest",
+    "pytest-xprocess"
+]
+
+[project.scripts]
+ztl_simple_client = "ztl.example.simple_client:main_cli"
+ztl_simple_server = "ztl.example.simple_server:main_cli"
+ztl_run_script = "ztl.script.run_script:main_cli"
+
+[project.urls]
+"Homepage" = "https://gitlab.com/robothouse/rh-user/ztl/"
+"Bug Tracker" = "https://gitlab.com/robothouse/rh-user/ztl/issues/"

ztl-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ztl-0.0.1/setup.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+from distutils.core import setup
+
+setup(name='ztl',
+      version='0.1',
+      description='A thin library relying on zmq to dispatch tasks',
+      author='Patrick Holthaus',
+      author_email='patrick.holthaus@googlemail.com',
+      url='https://gitlab.com/robothouse/rh-user/ztl/',
+      package_dir={'':'src'},
+      packages=['ztl', 'ztl.core', 'ztl.example', 'ztl.script'],
+      scripts=['src/ztl/example/simple_client.py',
+            'src/ztl/example/simple_server.py',
+            'src/ztl/script/run_script.py'
+      ]
+)

ztl-0.0.1/src/ztl/core/client.py

@@ -0,0 +1,109 @@
+import zmq
+import time
+import sys
+import logging
+logging.basicConfig(level=logging.INFO)
+
+from ztl.core.protocol import Message, Request, State
+
+class RemoteTask(object):
+
+  def __init__(self, host, port, scope, timeout=2000):
+
+    self.logger = logging.getLogger('remote-task')
+    self.context = zmq.Context()
+    self.socket = self.context.socket(zmq.REQ)
+    self.socket.setsockopt(zmq.RCVTIMEO, timeout)
+    address = "tcp://" + str(host) + ":" + str(port)
+    self.socket.connect(address)
+    self.scope = scope
+
+    self.logger.info("Remote task interface initialised at '%s'.", address)
+
+  def trigger(self, payload):
+    """
+    Trigger a task at the remote interface.
+
+    Parameters
+    ----------
+    payload: The payload containing the task description.
+
+    Returns
+    -------
+    id: An ID for the task assigned by the server if accepted, -1 if rejected or server not reachable or communication error.
+    """
+    msg = Message.encode(self.scope, Request.INIT, -1, payload)
+    try:
+      self.socket.send(msg)
+      reply = Message.decode(self.socket.recv())
+      return int(reply["id"])
+    except Exception as e:
+      self.logger.error(e)
+      return -1
+
+  def abort(self, mid, payload="abort command"):
+    """
+    Aborts a task at the remote interface.
+
+    Parameters
+    ----------
+    mid: The ID of the task to abort.
+    payload: An optional payload containing an updated task description. Default: "abort command"
+
+    Returns
+    -------
+    status: The updated status after attempting to abort. Task might not be aborted. -1 if server not reachable or communication error.
+    """
+    try:
+      msg = Message.encode(self.scope, Request.ABORT, mid, payload)
+      self.socket.send(msg)
+      reply = Message.decode(self.socket.recv())
+      return int(reply["state"])
+    except Exception as e:
+      self.logger.error(e)
+      return -1
+
+  def status(self, mid, payload="status update"):
+    """
+    Query the status of a given task at the remote interface.
+
+    Parameters
+    ----------
+    mid: The ID of the task to query about.
+    payload: An optional payload containing an updated task description. Default: "status update"
+
+    Returns
+    -------
+    id: The current status of the task at the server. -1 if server not reachable or communication error.
+    """
+    try:
+      msg = Message.encode(self.scope, Request.STATUS, mid, payload)
+      self.socket.send(msg)
+      reply = Message.decode(self.socket.recv())
+      return int(reply["state"])
+    except Exception as e:
+      self.logger.error(e)
+      return -1
+
+  def wait(self, mid, payload = "waiting poll", timeout = 5.0):
+    """
+    Wait for a task to complete at the remote interface.
+
+    Parameters
+    ----------
+    mid: The ID of the task to wait for.
+    payload: An optional payload containing an updated task description. Default: "waiting poll"
+    timeout: Maximum time to wait. Default: 5.0 secs.
+
+    Returns
+    -------
+    id: The last task status after waiting complete. -1 if server not reachable or communication error.
+    """
+    start = time.time()
+    state = -1
+    while (time.time() - start) < timeout and mid > 0:
+      state = self.status(mid, payload)
+      if state > State.ACCEPTED:
+        return state
+      time.sleep(.1)
+    return state

ztl-0.0.1/src/ztl/core/protocol.py

@@ -0,0 +1,69 @@
+import base64
+
+class Request:
+
+  INIT = 1
+  STATUS = 2
+  ABORT = 3
+
+  @staticmethod
+  def name(code):
+    if code == Request.INIT: return "INIT"
+    if code == Request.STATUS: return "STATUS"
+    if code == Request.ABORT: return "ABORT"
+    return None
+
+class State:
+
+  INITIATED = 0
+  ACCEPTED = 1
+  REJECTED = 2
+  FAILED = 3
+  ABORTED = 4
+  COMPLETED = 5
+
+  @staticmethod
+  def name(code):
+    if code == State.INITIATED: return "INITIATED"
+    if code == State.ACCEPTED: return "ACCEPTED"
+    if code == State.REJECTED: return "REJECTED"
+    if code == State.FAILED: return "FAILED"
+    if code == State.ABORTED: return "ABORTED"
+    if code == State.COMPLETED: return "COMPLETED"
+    return None
+
+class Message:
+
+  SEPARATOR = ";"
+  FIELDS = ["scope", "state", "id", "payload"]
+
+  @staticmethod
+  def encode(scope, state, mid, payload):
+    msg = {"scope": str(scope),
+           "state": str(state),
+           "id": str(mid),
+           "payload": str(payload)}
+    return (msg["scope"] + Message.SEPARATOR  + msg["state"] + Message.SEPARATOR + msg["id"] + Message.SEPARATOR + msg["payload"]).encode('utf-8')
+
+  @staticmethod
+  def decode(message):
+    split = message.decode("utf-8").split(Message.SEPARATOR)
+    unfolded = dict(zip(Message.FIELDS, split))
+    return unfolded
+
+
+class Task:
+
+  SEPARATOR = "^"
+  FIELDS = ["handler", "component", "goal"]
+
+  @staticmethod
+  def decode(message):
+    cmd = base64.b64decode(bytes(str(message).encode("utf-8"))).split(Task.SEPARATOR)
+    return dict(zip(Task.FIELDS, cmd))
+
+  @staticmethod
+  def encode(handler, component, goal):
+    joined = str(handler) + Task.SEPARATOR + str(component) + Task.SEPARATOR + str(goal)
+    code = base64.b64encode(joined.encode('utf-8'))
+    return code.decode("utf-8")

ztl-0.0.1/src/ztl/core/server.py

@@ -0,0 +1,102 @@
+import zmq
+import time
+import sys
+import logging
+logging.basicConfig(level=logging.INFO)
+
+from ztl.core.protocol import Message, Request, State
+
+class TaskServer(object):
+
+  def __init__(self, port):
+    self.logger = logging.getLogger('remote-task')
+    context = zmq.Context()
+    self.socket = context.socket(zmq.REP)
+    address = "tcp://*:" + str(port)
+    self.socket.bind(address)
+    self.controllers = {}
+    self.logger.info("Task Server listening at '%s'" % address)
+
+
+  def send_message(self, scope, mid, state, payload):
+    self.socket.send(Message.encode(scope, mid, state, payload))
+
+
+  def register(self, scope, controller):
+    """
+    Register a new controller for requests on a specific scope.
+
+    Parameters
+    ----------
+    scope: The scope for which the server should dispatch tasks to the controller. Will replace any existing controller for this scope.
+    controller: A controller object that will be called with requests (init, status, abort)
+    """
+
+    self.logger.info("Registering controller for scope '%s'." % scope)
+    self.controllers[scope] = controller
+
+
+  def unregister(self, scope):
+    """
+    Unregister any controller on a given scope.
+
+    Parameters
+    ----------
+    scope: The scope for which the server should not dispatch tasks any longer.
+    """
+    self.controllers[scope] = None
+    self.logger.info("Controller for scope '%s' removed." % scope)
+
+
+  def listen(self):
+    """
+    Begin listening to requests and dispatching them to any controllers if available. This method blocks until interrupted.
+
+    """
+    while True:
+      try:
+        message = self.socket.recv()
+        request = Message.decode(message)
+
+        if all(field in request for field in Message.FIELDS):
+
+          scope = request["scope"]
+          if scope in self.controllers:
+            controller = self.controllers[scope]
+
+            state = int(request["state"])
+            mid = int(request["id"])
+            payload = request["payload"]
+
+            try:
+              if state == Request.INIT:
+                ticket, response = controller.init(payload)
+                if ticket > 0:
+                  self.send_message(scope, State.ACCEPTED, ticket, response)
+                else:
+                  self.send_message(scope, State.REJECTED, ticket, response)
+              elif state == Request.STATUS:
+                status, response = controller.status(mid, payload)
+                self.send_message(scope, status, mid, response)
+              elif state == Request.ABORT:
+                status, response = controller.abort(mid, payload)
+                self.send_message(scope, status, mid, response)
+              else:
+                self.send_message(scope, State.REJECTED, mid, "Invalid request")
+            except Exception as e:
+              logging.error(e)
+              self.send_message(scope, State.FAILED, mid, "Controller threw exception: " + str(e))
+          else:
+            self.send_message(scope, State.REJECTED, -1, "No controller for scope: " + scope)
+            self.logger.warning("No controller for scope '%s', ignoring." % scope)
+
+        else:
+          self.send_message(scope, State.REJECTED, -1, "Unknown protocol")
+          self.logger.warning("Unknown command received '%s', ignoring." % message)
+
+      except Exception as e:
+        logging.error(e)
+        time.sleep(1)
+      except KeyboardInterrupt:
+        logging.error("Interrupted, exiting.")
+        sys.exit(1)

ztl-0.0.1/src/ztl/core/task.py

@@ -0,0 +1,95 @@
+import logging
+logging.basicConfig(level=logging.INFO)
+
+from threading import Thread
+from ztl.core.protocol import State
+
+
+class ExecutableTask(object):
+
+  def initialise(self):
+    return True
+
+
+  def execute(self):
+    return True
+
+
+  def abort(self):
+    return True
+
+
+class TaskController(object):
+
+  def init(self, payload):
+    return -1, "Not implemented"
+
+
+  def status(self, mid, payload):
+      return State.REJECTED, "Not implemented"
+
+
+  def abort(self, mid, payload):
+    return State.REJECTED, "Not implemented"
+
+
+class TaskExecutor(Thread):
+
+  def __init__(self, cls, *parameters):
+    Thread.__init__(self)
+    self.logger = logging.getLogger(type(cls).__name__)
+    self.cls = cls
+    self.parameters = parameters
+    self.task = None
+    self._state = State.INITIATED
+    self._prevent = False
+    self.start()
+
+
+  def run(self):
+    self.logger.debug("Initiating task with parameters '%s'...", self.parameters)
+    self.task = self.cls(*self.parameters)
+    success = self.task.initialise()
+    if success:
+      if not self._prevent:
+        self.logger.debug("Accepting and executing task...")
+        self._state = State.ACCEPTED
+        success = self.task.execute()
+        if success:
+          self.logger.debug("Task execution completed successfully.")
+          self._state = State.COMPLETED
+        else:
+          self.logger.debug("Task execution failed.")
+          self._state = State.FAILED
+      else:
+        self._state = State.FAILED
+        logging.warn("Task execution prevented during initialising.")
+    else:
+      self.logger.debug("Task initialising failed, rejecting task.")
+      self._state = State.REJECTED
+
+
+  def stop(self):
+    if self.task is None:
+      self.logger.debug("Preventing task from executing...")
+      self._prevent = True
+      self._state = State.ABORTED
+    else:
+      self.logger.debug("Aborting task execution...")
+      success = self.task.abort()
+      if success:
+        print("Task aborted successfully.")
+        self._state = State.ABORTED
+      else:
+        self.logger.debug("Task could not be aborted.")
+    return self._state
+
+
+  def abort(self):
+    print("Aborting immediately as requested...")
+    self._state = State.ABORTED
+    super().abort()
+
+
+  def state(self):
+    return self._state

ztl-0.0.1/src/ztl/example/simple_client.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+import sys
+
+from ztl.core.client import RemoteTask
+from ztl.core.protocol import State
+
+def main_cli():
+  host = sys.argv[1]
+  scope = sys.argv[2]
+  payload = sys.argv[3]
+
+  print("Connecting to host '%s' at scope '%s'..." % (host, scope))
+  task = RemoteTask(str(host), 5555, scope)
+  print("Triggering task with payload '%s'..." % payload)
+  mid = task.trigger(payload)
+
+  if mid > 0:
+    print("Waiting 5s for task with ID '%s'..." % mid)
+    state = task.wait(mid, 5)
+    if state < 0:
+      print("Could not wait for task with ID '%s'." % mid)
+    elif state <= State.ACCEPTED:
+      print("Aborting task with ID '%s'..." % mid)
+      state = task.abort(mid)
+      if state == State.ABORTED:
+        print("Task with ID '%s' aborted." % mid)
+      elif state <= State.ACCEPTED:
+        print("Could not abort Task with ID '%s', waiting for completion." % mid)
+        task.wait(mid)
+        print("Task with ID '%s' finished after unsuccessful abort signal." % mid)
+    else:
+      print("Task with ID '%s' finished while waiting." % mid)
+  else:
+    print("Task '%s' could not be triggered.")
+
+if __name__ == "__main__":
+
+  main_cli()

ztl-0.0.1/src/ztl/example/simple_server.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+import sys
+import time
+
+from ztl.core.server import TaskServer
+from ztl.core.protocol import State
+from ztl.core.task import ExecutableTask, TaskExecutor, TaskController
+
+
+class DummyTask(ExecutableTask):
+
+  def __init__(self, duration):
+    self.active = True
+    self.duration = duration
+
+  def initialise(self):
+    return True
+
+  def execute(self):
+    start = time.time()
+    while self.active and time.time() - start < self.duration:
+      time.sleep(.1)
+    return self.active
+
+  def abort(self):
+    self.active = False
+    return True
+
+
+class SimpleTaskController(TaskController):
+
+  def __init__(self):
+    self.current_id = 0
+    self.running = {}
+
+  def init(self, payload):
+    self.current_id += 1
+    print("Initialising Task ID '%s' (%s)..." % (self.current_id, payload))
+    self.running[self.current_id] = TaskExecutor(DummyTask, int(payload))
+    return self.current_id, ""
+
+  def status(self, mid, payload):
+    if mid in self.running:
+      print("Status Task ID '%s' (%s)..." % (mid, payload))
+      return self.running[mid].state(), mid 
+    else:
+      return State.REJECTED, "Invalid ID"
+
+
+  def abort(self, mid, payload):
+    if mid in self.running:
+      print("Aborting Task ID '%s' (%s)..." % (mid, payload))
+      return self.running[mid].stop(), mid
+    else:
+      return State.REJECTED, "Invalid ID"
+
+
+def main_cli():
+  scope = sys.argv[1]
+  server = TaskServer(5555)
+  server.register(scope, SimpleTaskController())
+  server.listen()
+
+
+if __name__ == "__main__":
+
+  main_cli()

ztl-0.0.1/src/ztl/script/run_script.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python
+
+import time
+import oyaml as yaml
+import argparse
+import os
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+from sys import stdin, exit
+from ztl.core.protocol import State, Task
+from ztl.core.client import RemoteTask
+
+class _Getch:
+    """Gets a single character from standard input.  Does not echo to the
+screen."""
+    def __init__(self):
+        try:
+            self.impl = _GetchWindows()
+        except ImportError:
+            self.impl = _GetchUnix()
+
+    def __call__(self): return self.impl()
+
+class _GetchUnix:
+    def __init__(self):
+        import tty, sys
+
+    def __call__(self):
+        import sys, tty, termios
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(sys.stdin.fileno())
+            ch = sys.stdin.read(1)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        return ch
+
+class _GetchWindows:
+    def __init__(self):
+        import msvcrt
+
+    def __call__(self):
+        import msvcrt
+        return msvcrt.getch()
+
+class ScriptExecutor(object):
+
+  tasks = {}
+
+  def __init__(self, configfile, scriptfile):
+    self.logger = logging.getLogger('script-exec')
+
+    self.getch = _Getch()
+
+    self.lastScene = None
+
+    with open(configfile) as f:
+      self.config = yaml.safe_load(f)
+
+      rs = self.config["remotes"]
+      for r in rs.keys():
+        self.logger.info("Initialising remote task interface '%s'..." % r)
+        self.tasks[r] = RemoteTask(rs[r]["host"], rs[r]["port"], rs[r]["scope"])
+
+    with open(scriptfile) as f:
+      self.script = yaml.safe_load(f)
+
+  def parse_stage(self, stage):
+    name = str(stage)
+    delay = 0
+    wait = True
+
+    o = name.find("(")
+    c = name.find(")")
+    if o > 0 and c > 0:
+      params = name[o+1:c]
+      name = name[0:o]
+      for param in params.split(","):
+        pp = param.split("=")
+        if len(pp) is 2:
+          key = pp[0].strip()
+          value = pp[1].strip()
+          if key == "delay":
+            delay = int(value)
+          if key == "wait":
+            wait = value.lower() in ['true', '1', 't', 'y', 'yes', 'on']
+    return name, delay, wait
+
+  def execute_scene(self, scene):
+
+    scene_name, scene_delay, scene_wait = self.parse_stage(scene)
+    steps = list(self.script[scene].keys())
+
+    print(("EXECUTING SCENE '%s'" % scene_name) + (" WITH DELAY %ss" % scene_delay if scene_delay > 0 else "") + "...")
+
+    if scene_delay > 0:
+      time.sleep(scene_delay)
+
+    for step in steps:
+      step_name, step_delay, step_wait = self.parse_stage(step)
+      print(("STARTING STEP '%s'" % step_name) + (" IN BACKGROUND" if not step_wait else "") + (" WITH DELAY %ss" % step_delay if step_delay > 0 else "") + "...")
+
+      if step_delay > 0:
+        time.sleep(step_delay)
+
+      task_ids = []
+      handlers = self.script[scene][step].keys()
+      for handler in handlers:
+        if handler in self.tasks:
+          components = self.script[scene][step][handler].keys()
+          for component in components:
+            component_name, component_delay, component_wait = self.parse_stage(component)
+            goal = self.script[scene][step][handler][component]
+
+            if component_delay > 0:
+              time.sleep(component_delay)
+
+            remote_id = self.tasks[handler].trigger(Task.encode(handler, component_name, goal))
+            if remote_id > 0:
+              if step_wait and component_wait:
+                task_ids.append(str(remote_id) + ":" + str(handler) + ":" + str(component_name) + ":" + str(goal))
+              else:
+                # MOVE TO DEBUG AFTER FINISHING THIS FEATURE
+                self.logger.info("Component '%s' on handler '%s' for step '%s' TRIGGERED TO RUN IN BACKGROUND." % (component_name, handler, step_name))
+            else:
+              self.logger.error("Component '%s' on handler '%s' for step '%s' COULD NOT BE TRIGGERED." % (component_name, handler, step_name))
+        else:
+          self.logger.error("No remote for handler '%s'. Step '%s' COULD NOT BE TRIGGERED." % (handler, step_name))
+
+      running = True
+      while running:
+        running = False
+        for task_id in task_ids:
+          components = task_id.split(":")
+          remote_id = int(components[0])
+          rid = components[1]
+          status = self.tasks[rid].wait(remote_id, task_id, timeout=100)
+          running = running or status <= State.ACCEPTED
+        time.sleep(.1)
+
+
+  def confirm_scene(self, scene):
+    print("\n----------------------------")
+    print("ABOUT TO EXECUTE SCENE '%s'" % scene)
+
+    steps = list(self.script[scene].keys())
+
+    for step in steps:
+      print("STEP: %s" % step)
+      handlers = self.script[scene][step].keys()
+      for handler in handlers:
+        components = self.script[scene][step][handler].keys()
+        for component in components:
+          goal = self.script[scene][step][handler][component]
+          print("\t%s [%s]: -> %s" % (handler, component, goal))
+
+    if self.lastScene == None:
+      print("PRESS <ENTER> TO CONFIRM or ANY OTHER KEY TO SKIP")
+      return self.get_key()
+    else:
+      print("PRESS <ENTER> TO CONFIRM, PRESS <R> TO REPLAY LAST SCENE OR ANY OTHER KEY TO SKIP")
+      return self.get_key()
+  
+  def get_key(self):
+    first_char = self.getch()
+    # The idea would be to allow further decomposition of the getch e.g. if arrows keys are pressed
+    return first_char
+
+  def execute(self):
+    try:
+        for scene in self.script.keys():
+          repeat = True
+          while repeat:
+            keyPressed = self.confirm_scene(scene)
+            if keyPressed == "\r" or keyPressed == b"\r":
+              self.execute_scene(scene)
+              self.lastScene = scene
+              repeat = False
+            elif self.lastScene != None and (keyPressed == "r" or keyPressed == "R" or keyPressed == b"r" or keyPressed == b"R"):
+              print("\n Repeating Scene '%s" % (self.lastScene))
+              self.execute_scene(self.lastScene)
+            else:
+              print("\nSKIPPING SCENE '%s'" % (scene))
+              repeat = False
+
+    except Exception as e:
+      self.logger.error(e)
+      exit(1)
+    except KeyboardInterrupt:
+      self.logger.error("Interrupted, exiting.")
+      exit(1)
+
+def main_cli():
+
+  cfg_file = os.environ.get('XDG_CONFIG_HOME', os.environ.get('HOME', '/home/demo') + '/.config') + '/zmq-remotes.yaml'
+
+  parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+  parser.add_argument("-c", "--config", type=str,
+                      help="Configuration file location.", default=cfg_file)
+  parser.add_argument("-s", "--script", type=str,
+                      help="Script file to execute.", required=True)
+
+  args, unknown = parser.parse_known_args()
+  run = ScriptExecutor(args.config, args.script)
+  run.execute()
+
+
+if __name__ == "__main__":
+
+  main_cli()
+

ztl-0.0.1/src/ztl.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: ztl
+Version: 0.0.1
+Summary: A thin library relying on zmq to dispatch tasks
+Home-page: https://gitlab.com/robothouse/rh-user/ztl/
+Author: Patrick Holthaus
+Author-email: Patrick Holthaus <patrick.holthaus@googlemail.com>
+License: BSD 2-Clause License
+        
+        Copyright (c) 2023, UH Robot House / User Projects
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://gitlab.com/robothouse/rh-user/ztl/
+Project-URL: Bug Tracker, https://gitlab.com/robothouse/rh-user/ztl/issues/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: oyaml
+Requires-Dist: pyzmq
+Requires-Dist: pytest
+Requires-Dist: pytest-xprocess
+
+This project contains the `ZTL` library enabling light-weight and widely compatible **remote task execution** using [ZeroMQ](https://zeromq.org/).
+
+The basic communication principle is as follows:
+
+![communication overview](res/overview.png)
+
+Thereby, each task has the following lifecycle:
+
+![task lifecycle](res/task%20lifecycle.png)
+
+An example communication could look like this:
+
+Request:
+
+![communication overview](res/protocol.png)
+
+Reply:
+
+![communication overview](res/protocol%20reply.png)

ztl-0.0.1/src/ztl.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/ztl/__init__.py
+src/ztl.egg-info/PKG-INFO
+src/ztl.egg-info/SOURCES.txt
+src/ztl.egg-info/dependency_links.txt
+src/ztl.egg-info/entry_points.txt
+src/ztl.egg-info/requires.txt
+src/ztl.egg-info/top_level.txt
+src/ztl/core/__init__.py
+src/ztl/core/client.py
+src/ztl/core/protocol.py
+src/ztl/core/server.py
+src/ztl/core/task.py
+src/ztl/example/__init__.py
+src/ztl/example/simple_client.py
+src/ztl/example/simple_server.py
+src/ztl/script/__init__.py
+src/ztl/script/run_script.py
+test/test_installation.py
+test/test_instances.py
+test/test_lifecycle.py

ztl-0.0.1/src/ztl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ztl-0.0.1/src/ztl.egg-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+ztl_run_script = ztl.script.run_script:main_cli
+ztl_simple_client = ztl.example.simple_client:main_cli
+ztl_simple_server = ztl.example.simple_server:main_cli

ztl-0.0.1/src/ztl.egg-info/requires.txt

@@ -0,0 +1,4 @@
+oyaml
+pyzmq
+pytest
+pytest-xprocess

ztl-0.0.1/src/ztl.egg-info/top_level.txt

@@ -0,0 +1 @@
+ztl

ztl-0.0.1/test/test_installation.py

@@ -0,0 +1,23 @@
+from unittest import TestCase
+
+class TestUnitTests(TestCase):
+
+    def test_unit_testing(self):
+        self.assertTrue(True)
+
+class TestImports(TestCase):
+
+    def test_zmq_import(self):
+        import zmq
+
+    def test_ztl_protocol_imports(self):
+        from ztl.core.protocol import Message, Request, State, Task
+
+    def test_ztl_server_imports(self):
+        from ztl.core.server import TaskServer
+
+    def test_ztl_client_imports(self):
+        from ztl.core.client import RemoteTask
+
+    def test_ztl_task_imports(self):
+        from ztl.core.task import ExecutableTask, TaskController, TaskExecutor

ztl-0.0.1/test/test_instances.py

@@ -0,0 +1,15 @@
+import pytest
+
+from unittest import TestCase
+
+from ztl.core.client import RemoteTask
+from ztl.core.server import TaskServer
+
+class TestConstruction(TestCase):
+
+  def test_server_construction(self):
+    server = TaskServer(6666)
+    server.register("/dummy", None)
+
+  def test_client_construction(self):
+    RemoteTask("localhost", 6666, "/dummy")

ztl-0.0.1/test/test_lifecycle.py

@@ -0,0 +1,75 @@
+import pytest
+
+from unittest import TestCase
+
+from ztl.core.client import RemoteTask
+from ztl.core.server import TaskServer
+from ztl.core.protocol import State
+
+@pytest.mark.usefixtures("ztl_server")
+class TestLocalLife(TestCase):
+
+  def test_no_controller(self):
+    host = "localhost"
+    scope = "/no"
+    payload = "does not matter"
+
+    task = RemoteTask("localhost", 7777, scope)
+    mid = task.trigger(payload)
+
+    assert mid < 0
+
+  def test_none_controller(self):
+    host = "localhost"
+    scope = "/none"
+    payload = "does not matter"
+
+    task = RemoteTask("localhost", 7777, scope)
+    mid = task.trigger(payload)
+
+    assert mid < 0
+
+@pytest.mark.usefixtures("ztl_simple_server")
+class TestLifeCycle(TestCase):
+
+  def test_reject(self):
+    host = "localhost"
+    scope = "/test"
+    payload = "illegal payload"
+
+    task = RemoteTask("localhost", 5555, scope)
+    mid = task.trigger(payload)
+
+    assert mid < 0
+
+  def test_abort(self):
+    host = "localhost"
+    scope = "/test"
+    payload = 5
+
+    task = RemoteTask("localhost", 5555, scope)
+    mid = task.trigger(payload)
+
+    assert mid > 0
+
+    state = task.wait(mid, .1)
+    assert state == State.ACCEPTED
+
+    state = task.abort(mid)
+    assert state == State.ABORTED
+
+  def test_completion(self):
+    host = "localhost"
+    scope = "/test"
+    payload = 5
+
+    task = RemoteTask("localhost", 5555, scope)
+    mid = task.trigger(payload)
+
+    assert mid > 0
+
+    state = task.wait(mid, .1)
+    assert state == State.ACCEPTED
+
+    state = task.wait(mid, 3.1)
+    assert state == State.COMPLETED