flexCommunicator 0.1.0__py3-none-any.whl

flexCommunicator/clientLibraries/flcpy/service/client.py

@@ -0,0 +1,58 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+import time
+import threading
+class client(object):
+    def __init__(self, name="tbd", service=None,logger=None,set_data=None):
+        self._name = name
+        self._service = service
+        self._isWaitingforService = False
+        self._cv = threading.Condition()
+        self._logger = logger
+        self._set_data = set_data
+        self._done_callback = None
+
+    @property
+    def service(self):
+        return self._service
+
+    @service.setter
+    def service(self, value):
+        self._service = value
+
+    def call_async(self,request):
+        self._logger.info("Async service <"+self.service.name+"> called.")
+        self._set_data(data_name=self._service.requestProperty, data=request)
+        self._isWaitingforService = True
+
+    def spin_until_future_complete(self, timeout=5.0):
+        # Wait for response or timeout
+        with self._cv:
+            if not self._cv.wait_for(lambda: not self._isWaitingforService, timeout=timeout):
+                self._isWaitingForService = False
+                self._logger.info("Async service <" + self.service.name + "> called failed, no response received within timeout ["+timeout.__str__()+" sec.].")
+                return -1
+
+        self._isWaitingForService = False
+        return self._service.response
+
+
+    def response_callback(self,request,response):
+        #set response
+        self.service.response.instantiate(json_str=response)
+        self._isWaitingforService = False
+
+        #DONE CALLBACK
+        if self._done_callback is not None:
+            self._done_callback(self.service.response)
+
+    def add_done_callback(self,callback=None):
+        self._done_callback = callback
+
+

flexCommunicator/clientLibraries/flcpy/service/service.py

@@ -0,0 +1,67 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+
+class service(object):
+    def __init__(self, name="tbd", request=None, response=None,callback=None,requestProperty=None, responseProperty=None):
+        self._name = name
+        self._request = request
+        self._response = response
+        self._requestProperty = requestProperty
+        self._responseProperty = responseProperty
+        self._callback = callback
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @property
+    def request(self):
+        return self._request
+
+    @request.setter
+    def request(self, value):
+        self._request = value
+
+    @property
+    def response(self):
+        return self._response
+
+    @response.setter
+    def response(self, value):
+        self._response = value
+
+    @property
+    def requestProperty(self):
+        return self._requestProperty
+
+    @requestProperty.setter
+    def requestProperty(self, value):
+        self._requestProperty = value
+
+    @property
+    def responseProperty(self):
+        return self._responseProperty
+
+    @responseProperty.setter
+    def responseProperty(self, value):
+        self._responseProperty = value
+
+    @property
+    def callback(self):
+        return self._callback
+
+    @callback.setter
+    def callback(self, value):
+        self._callback = value
+
+

flexCommunicator/clientLibraries/flcpy/transport/PropertyBinding.py

@@ -0,0 +1,108 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+from enum import Enum
+from typing import Optional
+
+
+class Direction(Enum):
+    """Direction of data flow for a property."""
+    IN = "in"
+    OUT = "out"
+    INOUT = "inout"
+
+
+class MqttBinding:
+    """Binding configuration for MQTT transport."""
+    def __init__(self, topic: str, QoS: Optional[int] = 10):
+        self.topic = topic
+        self.QoS = QoS
+        self.generic_endpoint = topic
+
+
+class RedisBinding:
+    """Binding configuration for Redis transport."""
+    def __init__(self, key: str):
+        self.key = key
+        self.generic_endpoint = key
+
+
+class OpcUaBinding:
+    """Binding configuration for OPC-UA transport."""
+    def __init__(self, node_id: Optional[str] = None, endpoint: Optional[str] = None):
+        self.node_id = node_id
+        self.endpoint = endpoint
+        self.generic_endpoint = endpoint
+
+class TwincatAdsBinding:
+    """Binding configuration for TWINCAT-ADS transport."""
+    def __init__(self, data_name: Optional[str] = None):
+        self.data_name = data_name
+        self.generic_endpoint = data_name
+
+class RabbitMqBinding:
+    """Binding configuration for RabbitMQ transport."""
+    def __init__(self, exchange: str, routing_key: str):
+        self.exchange = exchange
+        self.routing_key = routing_key
+        self.generic_endpoint = routing_key
+
+
+class KafkaBinding:
+    """Binding configuration for Kafka transport."""
+    def __init__(self, topic: str, partition: Optional[int] = None):
+        self.topic = topic
+        self.partition = partition
+        self.generic_endpoint = topic
+
+
+class ZenohBinding:
+    """Binding configuration for Zenoh transport."""
+    def __init__(self, resource_key: str):
+        self.resource_key = resource_key
+        self.generic_endpoint = resource_key
+
+
+class PropertyBinding:
+    """
+    Represents a property with metadata and its transport-specific bindings.
+
+    Attributes:
+        name (str): Logical name of the property.
+        description (Optional[str]): Human-readable description.
+        direction (Direction): Data flow direction (in, out, or inout).
+        mqtt (Optional[MqttBinding]): MQTT binding.
+        redis (Optional[RedisBinding]): Redis binding.
+        opc_ua (Optional[OpcUaBinding]): OPC-UA binding.
+        rabbitmq (Optional[RabbitMqBinding]): RabbitMQ binding.
+        kafka (Optional[KafkaBinding]): Kafka binding.
+        zenoh (Optional[ZenohBinding]): Zenoh binding.
+    """
+    def __init__(
+        self,
+        name: str,
+        description: Optional[str],
+        protocol: str,
+        mqtt: Optional[MqttBinding] = None,
+        redis: Optional[RedisBinding] = None,
+        opc_ua: Optional[OpcUaBinding] = None,
+        rabbitmq: Optional[RabbitMqBinding] = None,
+        kafka: Optional[KafkaBinding] = None,
+        zenoh: Optional[ZenohBinding] = None,
+        twincat_ads: Optional[TwincatAdsBinding] = None,
+    ):
+        self.name = name
+        self.description = description
+        self.protocol = protocol
+        self.mqtt = mqtt
+        self.redis = redis
+        self.opc_ua = opc_ua
+        self.rabbitmq = rabbitmq
+        self.kafka = kafka
+        self.zenoh = zenoh
+        self.twincat_ads = twincat_ads

flexCommunicator/clientLibraries/flcpy/transport/PropertyRegistry.py

@@ -0,0 +1,142 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+from flexCommunicator.clientLibraries.flcpy.transport.PropertyBinding import *
+from typing import Optional, Dict
+import yaml
+
+
+KEY_Property_Registry = "Communication_Matrix"
+
+class PropertyRegistry:
+    """
+    Loads and stores PropertyBinding instances from a YAML config.
+
+    Methods:
+        get_binding(name: str, transport: str) -> object
+            Return the binding object for the given property name and transport type.
+    """
+    def __init__(self, config_path: str):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)
+
+        self._registry: Dict[str, PropertyBinding] = {}
+        commMatrix = self.config[KEY_Property_Registry]
+        for entry in commMatrix.get('properties', []):
+            mqtt_binding = entry['property'].get('mqtt')
+            redis_binding = entry['property'].get('redis')
+            opc_ua_binding = entry['property'].get('opc_ua')
+            rabbitmq_binding = entry['property'].get('rabbitmq')
+            kafka_binding = entry['property'].get('kafka')
+            zenoh_binding = entry['property'].get('zenoh')
+            twincat_ads_binding = entry['property'].get('twincat_ads')
+
+            pb = PropertyBinding(
+                name=entry['property']['name'],
+                description=entry['property'].get('description'),
+                protocol=entry['property'].get('protocol'),
+                mqtt=MqttBinding(**mqtt_binding) if mqtt_binding else None,
+                redis=RedisBinding(**redis_binding) if redis_binding else None,
+                opc_ua=OpcUaBinding(**opc_ua_binding) if opc_ua_binding else None,
+                rabbitmq=RabbitMqBinding(**rabbitmq_binding) if rabbitmq_binding else None,
+                kafka=KafkaBinding(**kafka_binding) if kafka_binding else None,
+                zenoh=ZenohBinding(**zenoh_binding) if zenoh_binding else None,
+                twincat_ads=TwincatAdsBinding(**twincat_ads_binding) if twincat_ads_binding else None
+            )
+            self._registry[pb.name] = pb
+
+    def get_binding(self, name: str, transport: str):
+        """
+        Retrieve the binding configuration for a property by name and transport.
+
+        Args:
+            name (str): The property name.
+            transport (str): One of 'mqtt', 'redis', 'opc_ua', 'rabbitmq', 'kafka', 'zenoh'.
+
+        Returns:
+            The corresponding binding object.
+
+        Raises:
+            KeyError: If the property or transport binding does not exist.
+        """
+        pb = self._registry.get(name)
+        if not pb:
+            raise KeyError(f"No property with name '{name}' found.")
+
+        transport = transport.lower()
+        binding = getattr(pb, transport, None)
+        if not binding:
+            raise KeyError(f"No binding for transport '{transport}' on property '{name}'.")
+        return binding
+
+    def get_transport(self, name: str):
+        """
+        Retrieve the transport protocol for a property by name .
+
+        Args:
+            name (str): The property name.
+
+        Returns:
+            The corresponding binding object.
+
+        Raises:
+            KeyError: If the property or transport binding does not exist.
+        """
+        pb = self._registry.get(name)
+        if not pb:
+            raise KeyError(f"No property with name '{name}' found.")
+
+
+        protocol = getattr(pb, "protocol", None)
+        if not protocol:
+            raise KeyError(f"No transport protocol defined for property '{name}'.")
+        return protocol
+
+    def update_transport(self, name: str, transport: str):
+        """ Update current property transport"""
+        pb = self._registry.get(name)
+        if not pb:
+            raise KeyError(f"No property with name '{name}' found.")
+        try:
+            setattr(pb, "protocol", transport)
+            return True
+        except:
+            raise Exception(f"Transport could not be changed for property '{name}'.")
+
+    def update_endpoint(self, name: str, endpoint: str):
+        """ Update current property endpoint"""
+        pb = self._registry.get(name)
+        if not pb:
+            raise KeyError(f"No property with name '{name}' found.")
+        try:
+            if pb.protocol == "mqtt":                       #TODO: make this more generic and less hardcoded
+                pb.mqtt.generic_endpoint = endpoint
+                pb.mqtt.topic = endpoint
+            else:
+                print(f"Endpoint update for transport '{pb.protocol}' is not implemented yet.")
+                return False
+            return True
+        except:
+            raise Exception(f"Endpoint could not be changed for property '{name}'.")
+
+    def add_property(self,name="TBD",description="TBD",protocol=None,mqtt=None,redis=None,opc_ua=None,rabbitmq=None,kafka=None,zenoh=None,twincat_ads=None):
+        """ Manual add property to transport"""
+        pb = PropertyBinding(
+            name=name,
+            description=description,
+            protocol=protocol,
+            mqtt=MqttBinding(topic=mqtt,QoS=2) if mqtt else None,
+            redis=RedisBinding(key=redis) if redis else None,
+            opc_ua=OpcUaBinding(node_id=opc_ua) if opc_ua else None,
+            rabbitmq=RabbitMqBinding(routing_key=rabbitmq) if rabbitmq else None,
+            kafka=KafkaBinding(topic=kafka) if kafka else None,
+            zenoh=ZenohBinding(resource_key=zenoh) if zenoh else None,
+            twincat_ads=TwincatAdsBinding(data_name=twincat_ads) if twincat_ads else None
+        )
+        self._registry[pb.name] = pb
+

flexCommunicator/clientLibraries/flcpy/utils/Timer.py

@@ -0,0 +1,22 @@
+import threading
+import time
+
+class Timer:
+    def __init__(self, period_sec, callback):
+        self._period = period_sec
+        self._callback = callback
+        self._running = False
+        self._thread = threading.Thread(target=self._run)
+
+    def _run(self):
+        while self._running:
+            time.sleep(self._period)
+            self._callback()
+
+    def start(self):
+        self._running = True
+        self._thread.start()
+
+    def stop(self):
+        self._running = False
+        self._thread.join()

flexCommunicator/clientLibraries/flcpy/utils/auxiliary.py

@@ -0,0 +1,261 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+from threading import Timer
+import yaml
+import configparser
+import random
+import uuid
+import subprocess
+import os
+import json
+import datetime
+class perpetualTimer():
+
+   def __init__(self,t,hFunction):
+      self.t=t
+      self.hFunction = hFunction
+      #self.thread = Timer(self.t,self.handle_function)
+      self.thread = Timer(self.t, self.handle_function)
+      x=1
+
+   def handle_function(self):
+      self.hFunction()
+      self.thread = Timer(self.t,self.handle_function)
+      self.thread.start()
+
+   def start(self):
+      self.thread.start()
+
+   def cancel(self):
+      self.thread.cancel()
+
+   def isAlive(self):
+      return self.thread.is_alive()
+
+
+def get_timestamp():
+   return datetime.datetime.now(datetime.timezone.utc).isoformat().replace("+00:00", "Z")
+
+def load_config(config_file):
+  with open(config_file, 'r') as file:
+      return yaml.safe_load(file)
+
+
+def load_flexia_config(config_file):
+   # read the configuration file
+   config = configparser.ConfigParser()
+   config.optionxform = str  # preserve case of keys
+   config.read(config_file)
+
+   data = {}
+
+   # Process all sections
+   for section in config.sections():
+      if ":" in section:
+         # Split sections like 'build:Oberon-5' into prefix and variable name
+         prefix, variable = section.split(":", 1)
+         if prefix not in data:
+            data[prefix] = {}
+         data[prefix][variable] = dict(config[section])
+      else:
+         data[section] = dict(config[section])
+
+   return data
+
+
+def generate_random_name(separator="_"):
+   """
+   Generates a random name similar to Docker's naming scheme, with an optional UUID.
+
+   Args:
+       separator (str): The character to separate the adjective and the noun (default: "_").
+
+   Returns:
+       str: A randomly generated name with a UUID.
+   """
+   adjectives = [
+      "adoring", "brave", "clever", "daring", "eager", "frosty",
+      "gentle", "happy", "jolly", "kind", "lively", "mighty",
+      "noble", "optimistic", "peaceful", "quirky", "radiant",
+      "spirited", "trusty", "upbeat", "vivid", "witty", "youthful",
+      "zesty", "dynamic", "bold", "charming", "elegant", "fiery",
+      "graceful", "heroic", "inventive", "joyful", "keen", "legendary",
+      "marvelous", "nimble", "outgoing", "plucky", "quick", "resilient",
+      "sturdy", "tenacious", "vibrant", "whimsical", "zealous"
+   ]
+
+   nouns = [
+      "einstein", "curie", "turing", "lovelace", "newton", "galileo",
+      "tesla", "hopper", "feynman", "darwin", "goodall", "carson",
+      "babbage", "franklin", "leonardo", "plato", "aristotle", "shakespeare",
+      "copernicus", "fermat", "noether", "gauss", "archimedes", "pythagoras",
+      "pasteur", "edison", "faraday", "kepler", "bohr", "planck",
+      "heisenberg", "ramanujan", "meitner", "daguerre", "volta", "da_vinci",
+      "marconi", "brunel", "darwin", "maxwell", "cavendish", "hawking",
+      "lamarr", "carver", "knuth", "von_neumann", "mendel", "sagan"
+   ]
+
+   # Choose a random adjective and noun
+   adjective = random.choice(adjectives)
+   noun = random.choice(nouns)
+
+   # Generate a random UUID
+   unique_id = uuid.uuid4().hex[:4]  # Shorten the UUID to 8 characters
+
+   # Combine with the separator and return
+   return f"{adjective}{separator}{noun}{separator}{unique_id}"
+
+
+def generate_key(length=4):
+   return uuid.uuid4().hex[:length]
+
+
+import yaml
+
+
+def generate_config(name, platformID, primaryHardwareID, projectID, key, shared_secret, filename="communicationMatrix.yaml"):
+   config = {
+      "logging": {
+         "level": "DEBUG",
+         "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+         "file": "logs/syslog_local.log",
+         "remote": True
+      },
+      "flexCloud": {
+         "storage_type": "global",
+         "redis_host": "localhost",
+         "redis_port": 6379,
+         "redis_db": 6
+      },
+      "deviceCredentials": {
+         "name": name,
+         "platformID": platformID,
+         "primaryHardwareID": primaryHardwareID,
+         "projectID": projectID,
+         "key": key,
+         "shared_secret": shared_secret
+      },
+      "heartbeat": {
+         "heartbeat_interval": 10,
+         "ttl": 12
+      }
+   }
+   if filename is not None:
+      with open(filename, "w") as file:
+         yaml.dump(config, file, default_flow_style=False, sort_keys=False)
+   else:
+      print(config)
+
+
+def get_git_remote_url(folder: str) -> str:
+   """
+   Determines the Git remote URL from a given folder.
+
+   Args:
+       folder (str): The path to the folder.
+
+   Returns:
+       str: The Git remote URL if found, otherwise an empty string.
+   """
+   if not os.path.isdir(folder):
+      raise ValueError(f"The provided path '{folder}' is not a valid directory.")
+
+   try:
+      # Navigate to the folder and check if it's a git repository
+      git_dir = os.path.join(folder, ".git")
+      if not os.path.isdir(git_dir):
+         raise ValueError(f"The provided folder '{folder}' is not a Git repository.")
+
+      # Get the remote URL
+      result = subprocess.run(
+         ["git", "config", "--get", "remote.origin.url"],
+         cwd=folder,
+         capture_output=True,
+         text=True,
+         check=True
+      )
+
+      return result.stdout.strip() if result.stdout else ""
+
+   except subprocess.CalledProcessError:
+      return ""
+
+def yaml_to_json(yaml_path: str, json_path: str = None, *, sort_keys: bool = False, indent: int = 2) -> str:
+   """
+   Load a YAML file and convert it to JSON.
+
+   Args:
+       yaml_path: Path to the input YAML file.
+       json_path: Optional path to write the JSON output. If None, won’t write to disk.
+       sort_keys: Whether to sort the keys in the output JSON.
+       indent: Number of spaces to use for JSON indentation.
+
+   Returns:
+       The JSON string representation of the YAML content.
+   """
+   # Read YAML
+   with open(yaml_path, 'r', encoding='utf-8') as yf:
+      data = yaml.safe_load(yf)
+
+   # Convert to JSON string
+   json_str = json.dumps(data, sort_keys=sort_keys, indent=indent)
+
+   # Optionally write to file
+   if json_path:
+      with open(json_path, 'w', encoding='utf-8') as jf:
+         jf.write(json_str)
+
+   return json_str
+
+import json
+import yaml
+
+def json_to_yaml(
+    json_str,
+    yaml_path: str = None,
+    *,
+    sort_keys: bool = False,
+    default_flow_style: bool = False,
+    indent: int = 2
+) -> str:
+    """
+    Load a JSON file and convert it to YAML.
+
+    Args:
+        json_path: Path to the input JSON file.
+        yaml_path: Optional path to write the YAML output. If None, won’t write to disk.
+        sort_keys: Whether to sort the keys in the output YAML.
+        default_flow_style: If True, uses block style; if False, uses flow style for collections.
+        indent: Number of spaces to use for YAML indentation.
+
+    Returns:
+        The YAML string representation of the JSON content.
+    """
+    # Read JSON
+    #with open(json_path, 'r', encoding='utf-8') as jf:
+    #    data = json.load(jf)
+    try:
+      data = json.load(json_str)
+    except:
+       data = json_str
+
+    # Convert to YAML string
+    yaml_str = yaml.safe_dump(
+        data,
+        sort_keys=sort_keys,
+        default_flow_style=default_flow_style,
+        indent=indent
+    )
+
+    # Optionally write to file
+    if yaml_path:
+        with open(yaml_path, 'w', encoding='utf-8') as yf:
+            yf.write(yaml_str)
+
+    return yaml_str