zfl 0.1.1__tar.gz

zfl-0.1.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.

zfl-0.1.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: zfl
+Version: 0.1.1
+Summary: Data server via HTTPS POST
+Author-email: Patrick Holthaus <patrick.holthaus@googlemail.com>
+License-Expression: BSD-2-Clause
+Project-URL: Homepage, https://gitlab.com/robothouse/rh-projects/hospital-at-home/data-server/
+Project-URL: Bug Tracker, https://gitlab.com/robothouse/rh-projects/hospital-at-home/data-server/issues/
+Classifier: Programming Language :: Python
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: cherrypy
+Requires-Dist: ztl>=0.3.1
+Dynamic: license-file
+
+# Data Server
+
+This will become the project to enable data transfer and logging

zfl-0.1.1/README.md

@@ -0,0 +1,3 @@
+# Data Server
+
+This will become the project to enable data transfer and logging

zfl-0.1.1/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "zfl"
+version = "0.1.1"
+authors = [
+  { name="Patrick Holthaus", email="patrick.holthaus@googlemail.com" },
+]
+description = "Data server via HTTPS POST"
+readme = "README.md"
+license = "BSD-2-Clause"
+license-files = [ "LICENSE" ]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python",
+    "Operating System :: OS Independent"
+]
+dependencies = [
+    "requests",
+    "cherrypy",
+    "ztl >= 0.3.1"
+]
+
+[project.urls]
+"Homepage" = "https://gitlab.com/robothouse/rh-projects/hospital-at-home/data-server/"
+"Bug Tracker" = "https://gitlab.com/robothouse/rh-projects/hospital-at-home/data-server/issues/"
+
+[project.scripts]
+zfl_logging_service = "zfl.local.federated_logging_service:main_cli"
+zfl_cloud_server = "zfl.server.federated_cloud_service:main_cli"

zfl-0.1.1/setup.cfg

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

zfl-0.1.1/src/zfl/examples/local_logging_test.py

@@ -0,0 +1,20 @@
+import pprint
+
+from zfl.logging.state import CachedLocalLog
+
+if __name__ == "__main__":
+
+  l = CachedLocalLog()
+  l.add_state({"some data": "hello"})
+  l.add_state({"some other data": "something"})
+  l.add_state({"some other data": "something2"})
+  l.add_state({"dhey": 4})
+  l.add_state({"some data": "hello"})
+  l.add_state({"some other data": "something"})
+  l.add_state({"some other data": "something2"})
+  l.add_state({"dhey": 4})
+  l.add_state({"some data": "hello"})
+  l.add_state({"some other data": "something"})
+  l.add_state({"some other data": "something2"})
+  l.add_state({"dhey": 4})
+  pprint.pp(l.get_state())

zfl-0.1.1/src/zfl/examples/main_logging_example.py

@@ -0,0 +1,20 @@
+import pprint
+from zfl.logging.state import SystemState
+
+def some_function(obj):
+  print(obj)
+
+if __name__ == "__main__":
+
+  state = SystemState()
+
+  # Update status (indicate whether cloud needs to be notified as well)
+  pprint.pp(state.update_state({"persondetection": {"id": 2, "state": "present"}}, cloud = True))
+
+  # Retrieve latest status
+  state.update_state('{"something": "sdf"}')
+  pprint.pp(state.get_state())
+
+  # Alternative: register callback
+  # state.dispatch_updates(some_function)
+

zfl-0.1.1/src/zfl/examples/simple_http_client.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+import requests
+
+if __name__ == '__main__':
+  headers = {'Content-Type': 'application/json'}
+  response = requests.post('http://localhost:8080/process', headers=headers, json={"test":"value"}, verify=False)
+  response.raise_for_status()
+  print(response.url)
+  print(str(response.status_code) + ": " + response.json())

zfl-0.1.1/src/zfl/examples/state_subscriber.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+
+import argparse
+import time
+
+from ztl.core.subscriber import ObjectSubscriber
+from ztl.core.config import ZMQEndpoints
+
+def callback(obj):
+    print("received an object")
+
+
+def main_cli():
+
+  endpoints = ZMQEndpoints()
+  sub = endpoints.get_subscriber("federation")
+  sub.register_callback(callback)
+  s = sub.register_callback(print)
+
+  try:
+    sub.start()
+    time.sleep(5)
+    sub.remove_callback(s)
+
+  except KeyboardInterrupt:
+    print("Exit signal received.")
+    sub.stop()
+
+
+if __name__ == "__main__":
+
+  main_cli()

zfl-0.1.1/src/zfl/examples/ztl_http_client.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+
+import argparse
+import requests
+
+from ztl.core.server import TaskServer
+from ztl.core.protocol import State, Task
+from ztl.core.task import ExecutableTask, TaskExecutor, TaskController
+
+
+class HTTPSPostTask(ExecutableTask):
+
+  def __init__(self, remote, request):
+    self.headers = {'Content-Type': 'application/json'}
+    self.remote = remote
+    self.request = request
+
+  def execute(self):
+    response = requests.post(self.remote, headers=self.headers, json=self.request, verify=False)
+    response.raise_for_status()
+    return response.json()
+
+  def abort(self):
+    return False
+
+
+class Controller(TaskController):
+
+  def __init__(self, remote):
+    super(Controller, self).__init__()
+    self.remote = remote
+
+  def assign(self, handler, component, goal):
+    return HTTPSPostTask, self.remote, dict(zip(Task.FIELDS, [handler, component, goal]))
+
+def main_cli():
+
+  parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+  parser.add_argument("-p", "--port", type=int,
+                      help="The port on the local machine that the server should listen to.", required=True)
+  parser.add_argument("-s", "--scope", type=str,
+                      help="The scope that the server should respond to.", required=True)
+  parser.add_argument("-r", "--remote", type=str,
+                      help="The remote server address.", required=True)
+
+  args, unknown = parser.parse_known_args()
+
+  server = TaskServer(args.port)
+  server.register(args.scope, Controller(args.remote))
+  server.listen()
+
+if __name__ == "__main__":
+
+  main_cli()

zfl-0.1.1/src/zfl/local/federated_logging_service.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+
+import argparse
+import requests
+import json
+
+from ztl.core.server import TaskServer
+from ztl.core.protocol import State, Task
+from ztl.core.task import ExecutableTask, TaskExecutor, TaskController
+from ztl.core.publisher import ObjectPublisher
+from ztl.core.config import ZMQEndpoints
+
+from zfl.local.syslog import CachedLocalLog
+
+class StatusUpdateTask(ExecutableTask):
+
+  def __init__(self, syslog, publisher, goal, remote = None):
+    self.headers = {'Content-Type': 'application/json'}
+    self.syslog = syslog
+    self.remote = remote
+    self.publisher = publisher
+    self.update = json.loads(goal)
+
+  def execute(self):
+    # local update (always performed)
+    self.syslog.add_state(self.update)
+    new_state = self.syslog.get_state()
+    self.publisher.publish(new_state)
+
+    # remote update (only if requested)
+    if self.remote is None:
+      return new_state
+
+    request = {'handler': "something",
+                'component': "something",
+                'goal': self.update
+              }
+
+    response = requests.post(self.remote, headers=self.headers, json=request, verify=False)
+    response.raise_for_status()
+    return new_state, response.json()
+
+
+class StatusRequestTask(ExecutableTask):
+
+  def __init__(self, syslog, goal):
+    self.syslog = syslog
+    self.goal = goal
+
+  def execute(self):
+    return self.syslog.get_state()
+
+class SystemStateController(TaskController):
+
+  def __init__(self, remote, publisher, syslog):
+    super(SystemStateController, self).__init__()
+    self.remote = remote
+    self.syslog = syslog
+    self.publisher = publisher
+
+  def assign(self, handler, component, goal):
+    if handler == "system":
+      if component == "update":
+        return StatusUpdateTask, self.syslog, self.publisher, goal
+      elif component == "remote":
+        return StatusUpdateTask, self.syslog, self.publisher, goal, self.remote
+      elif component == "status":
+        return StatusRequestTask, self.syslog, goal
+      raise RuntimeError("No such component '%s', try 'remote', 'local', 'status'." % handler)
+    raise RuntimeError("No such handler '%s', try 'system'." % handler)
+
+
+def main_cli():
+
+  parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+  parser.add_argument("-r", "--remote", type=str,
+                      help="The remote server address.", required=True)
+
+  endpoints = ZMQEndpoints(parser = parser)
+  args, unknown = parser.parse_known_args()
+
+  if not endpoints.has_remote("federation"):
+    raise RuntimeError("Federation remote not provided, found: %s. Check configuration file (--config) or provide runtime parameters (--task)." % list(endpoints.config["remotes"].keys()))
+
+  if not endpoints.has_publisher("federation"):
+    raise RuntimeError("Federation publisher not provided, found: %s. Check configuration file (--config) or provide runtime parameters (--publisher)." % list(endpoints.config["publishers"].keys()))
+
+  publisher_conf = endpoints.get_publisher_config("federation")
+  remote_conf = endpoints.get_remote_config("federation")
+
+  publisher = ObjectPublisher(publisher_conf["port"], publisher_conf["scope"])
+  syslog = CachedLocalLog()
+  server = TaskServer(remote_conf["port"])
+
+  server.register(remote_conf["scope"], SystemStateController(args.remote, publisher, syslog))
+  server.listen()
+
+if __name__ == "__main__":
+
+  main_cli()

zfl-0.1.1/src/zfl/local/syslog.py

@@ -0,0 +1,55 @@
+import yaml
+import time
+import os
+import pprint
+from copy import deepcopy
+import uuid
+
+class CachedLocalLog(object):
+
+  def __init__(self, directory = None, filename = "local-state.yaml", cachesize = 5):
+    if directory is None:
+      directory = os.path.join(os.environ.get('XDG_DATA_HOME', os.environ.get('HOME', '/home/demo') + '/.local/share'), "hospitalathome/cache")
+
+    self.requests = 0
+    self.cachesize = cachesize
+    os.makedirs(directory, exist_ok=True)
+    logname = os.path.join(directory, filename)
+    print("Opening logfile '%s'..." % logname)
+    self.logfile = open(logname, 'w')
+
+    self.logdata = {
+      self.requests: {
+        "timestamp" : 0,
+        "uuid": 0,
+        "data": {}
+      }
+    }
+
+    self.metadata = {
+        "filename": logname,
+        "initiated": time.time(),
+        "format": "v0.1"
+    }
+
+
+  def add_state(self, data, write_file = True):
+    if not type(data) is dict:
+      raise RuntimeError("Can only log dict type data")
+
+    oldkey = self.requests % self.cachesize
+    newkey = (self.requests + 1) % self.cachesize
+
+    origin = deepcopy(self.logdata[oldkey]["data"])
+    self.logdata[newkey] = {
+      "data": origin | data,
+      "timestamp": time.time(),
+      "uuid": str(uuid.uuid4())
+    }
+
+    yaml.dump({self.requests: self.logdata[newkey]}, self.logfile)
+    self.requests = self.requests + 1
+
+
+  def get_state(self):
+    return self.logdata

zfl-0.1.1/src/zfl/logging/state.py

@@ -0,0 +1,46 @@
+import os
+import json
+
+from ztl.core.config import ZMQEndpoints
+from ztl.core.protocol import Task
+
+class SystemState(object):
+
+  def __init__(self):
+
+    endpoints = ZMQEndpoints()
+    if not endpoints.has_remote("federation"):
+      raise RuntimeError("Federation remote not provided, found: %s. Check configuration file (--config) or provide runtime parameters (--task)." % list(endpoints.config["remotes"].keys()))
+
+    if not endpoints.has_publisher("federation"):
+      raise RuntimeError("Federation publisher not provided, found: %s. Check configuration file (--config) or provide runtime parameters (--publisher)." % list(endpoints.config["publishers"].keys()))
+
+    self.remote = endpoints.get_remote("federation")
+    self.subscriber = endpoints.get_subscriber("federation")
+    self.listening = False
+
+  def update_state(self, data, cloud = False):
+    if type(data) is dict:
+      data = json.dumps(data)
+
+    if cloud:
+      component = "remote"
+    else:
+      component = "update"
+
+    mid, reply = self.remote.trigger(Task.encode("system", component, data))
+    state, reply = self.remote.wait(mid)
+
+    return reply
+
+  def get_state(self):
+    mid, reply = self.remote.trigger(Task.encode("system", "status", ""))
+    state, reply = self.remote.wait(mid)
+
+    return reply
+
+  def dispatch_updates(self, callback):
+    self.subscriber.register_callback(callback)
+    if not self.listening:
+      self.subscriber.start()
+      self.listening = True

zfl-0.1.1/src/zfl/server/federated_cloud_service.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+
+import cherrypy
+
+class JSONDataService(object):
+
+    @cherrypy.expose
+    @cherrypy.tools.json_out()
+    @cherrypy.tools.json_in()
+    def process(self):
+        request = cherrypy.request.json
+        print(request)
+        if not "handler" in request.keys():
+            raise cherrypy.HTTPError(406, "handler undefined")
+        if not "component" in request.keys():
+            raise cherrypy.HTTPError(406, "component undefined")
+        if not "goal" in request.keys():
+            raise cherrypy.HTTPError(406, "goal undefined")
+        else:
+            with cherrypy.HTTPError.handle(Exception):
+                return self.handle(request["handler"], request["component"], request["goal"])
+
+    def handle(self, handler, component, goal):
+        print("handler: %s, component: %s, goal: %s" % (handler, component, goal))
+        return "data printed successfully"
+
+def main_cli():
+    config = {'server.socket_host': '0.0.0.0',
+              # 'server.ssl_module': 'builtin',
+              # 'server.ssl_certificate': '/tmp/some.cer',
+              # 'server.ssl_private_key': '/tmp/some.key'
+    }
+    cherrypy.config.update(config)
+    cherrypy.quickstart(JSONDataService())
+
+
+if __name__ == "__main__":
+
+  main_cli()

zfl-0.1.1/src/zfl.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: zfl
+Version: 0.1.1
+Summary: Data server via HTTPS POST
+Author-email: Patrick Holthaus <patrick.holthaus@googlemail.com>
+License-Expression: BSD-2-Clause
+Project-URL: Homepage, https://gitlab.com/robothouse/rh-projects/hospital-at-home/data-server/
+Project-URL: Bug Tracker, https://gitlab.com/robothouse/rh-projects/hospital-at-home/data-server/issues/
+Classifier: Programming Language :: Python
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: cherrypy
+Requires-Dist: ztl>=0.3.1
+Dynamic: license-file
+
+# Data Server
+
+This will become the project to enable data transfer and logging

zfl-0.1.1/src/zfl.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/zfl/__init__.py
+src/zfl.egg-info/PKG-INFO
+src/zfl.egg-info/SOURCES.txt
+src/zfl.egg-info/dependency_links.txt
+src/zfl.egg-info/entry_points.txt
+src/zfl.egg-info/requires.txt
+src/zfl.egg-info/top_level.txt
+src/zfl/examples/local_logging_test.py
+src/zfl/examples/main_logging_example.py
+src/zfl/examples/simple_http_client.py
+src/zfl/examples/state_subscriber.py
+src/zfl/examples/ztl_http_client.py
+src/zfl/local/__init__.py
+src/zfl/local/federated_logging_service.py
+src/zfl/local/syslog.py
+src/zfl/logging/__init__.py
+src/zfl/logging/state.py
+src/zfl/server/__init__.py
+src/zfl/server/federated_cloud_service.py

zfl-0.1.1/src/zfl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zfl-0.1.1/src/zfl.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+zfl_cloud_server = zfl.server.federated_cloud_service:main_cli
+zfl_logging_service = zfl.local.federated_logging_service:main_cli

zfl-0.1.1/src/zfl.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests
+cherrypy
+ztl>=0.3.1

zfl-0.1.1/src/zfl.egg-info/top_level.txt

@@ -0,0 +1 @@
+zfl