flexCommunicator 0.1.0__py3-none-any.whl

flexCommunicator/clientLibraries/flcpy/action/action.py

@@ -0,0 +1,85 @@
+#**************************************************************************
+# * 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 action(object):
+    def __init__(self, name="tbd", request=None, response=None,feedback=None,callback=None,requestProperty=None, responseProperty=None,feedbackProperty=None):
+        self._name = name
+        self._request = request
+        self._response = response
+        self._feedback = feedback
+        self._requestProperty = requestProperty
+        self._responseProperty = responseProperty
+        self._feedbackProperty = feedbackProperty
+        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 feedback(self):
+        return self._feedback
+
+    @feedback.setter
+    def feedback(self, value):
+        self._feedback = 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 feedbackProperty(self):
+        return self._feedbackProperty
+
+    @feedbackProperty.setter
+    def feedbackProperty(self, value):
+        self._feedbackProperty = value
+
+    @property
+    def callback(self):
+        return self._callback
+
+    @callback.setter
+    def callback(self, value):
+        self._callback = value
+
+

flexCommunicator/clientLibraries/flcpy/action/action_client.py

@@ -0,0 +1,70 @@
+#**************************************************************************
+# * 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 ation_client(object):
+    def __init__(self, name="tbd", action=None,logger=None,set_data=None):
+        self._name = name
+        self._action = action
+        self._isWaitingforAction = False
+        self._cv = threading.Condition()
+        self._logger = logger
+        self._set_data = set_data
+        self._done_callback = None
+        self._feedback_callback = None
+
+    @property
+    def action(self):
+        return self._action
+
+    @action.setter
+    def action(self, value):
+        self._action = value
+
+    def call_async(self,request):
+        self._logger.info("Async action <"+self.action.name+"> called.")
+        self._set_data(data_name=self._action.requestProperty, data=request)
+        self._isWaitingforAction = 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._isWaitingforAction, timeout=timeout):
+                self._isWaitingforAction = False
+                self._logger.info("Async action <" + self.action.name + "> called failed, no response received within timeout ["+timeout.__str__()+" sec.].")
+                return -1
+
+        self._isWaitingforAction = False
+        return self._action.response
+
+
+    def response_callback(self,topic,response):
+        #set response
+        self.action.response.instantiate(json_str=response)
+        self._isWaitingforAction = False
+
+        #DONE CALLBACK
+        if self._done_callback is not None:
+            self._done_callback(self.action.response)
+
+    def feedback_callback(self,topic,feedback):
+        #set response
+        self.action.feedback.instantiate(json_str=feedback)
+
+        #DONE CALLBACK
+        if self._feedback_callback is not None:
+            self._feedback_callback(self.action.feedback)
+
+    def add_done_callback(self,callback=None):
+        self._done_callback = callback
+
+    def add_feedback_callback(self,callback=None):
+        self._feedback_callback = callback
+
+

flexCommunicator/clientLibraries/flcpy/action/goal_handle.py

@@ -0,0 +1,50 @@
+#**************************************************************************
+# * 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.utils.constants import *
+import jsonpickle
+class goal_handle(object):
+    def __init__(self, name="tbd", action=None,logger=None):
+        self._name = name
+        self._action = action
+        self._logger = logger
+
+    @property
+    def action(self):
+        return self._action
+
+    @action.setter
+    def action(self, value):
+        self._action = value
+
+    @property
+    def request(self):
+        return self._action.request
+
+    @request.setter
+    def request(self, value):
+        self._action.request = value
+
+    @property
+    def response(self):
+        return self._action.response
+
+    @response.setter
+    def response(self, value):
+        self._action.response = value
+
+    @property
+    def feedback(self):
+        return self._action.feedback
+
+    @feedback.setter
+    def feedback(self,value):
+        self._action.feedback = value
+
+
+

flexCommunicator/clientLibraries/flcpy/codec/ROS2Codec.py

@@ -0,0 +1,227 @@
+#**************************************************************************
+# * 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 base64
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Union
+import numpy as np
+import cv2
+
+@dataclass
+class DecodedImageMessage:
+    frame: Optional[np.ndarray]
+    encoding: str
+    metadata: Dict[str, Any]
+    stamp_sec: Optional[int]
+    stamp_nanosec: Optional[int]
+    frame_id: Optional[str]
+    height: Optional[int]
+    width: Optional[int]
+    ros_encoding: Optional[str]
+    is_bigendian: Optional[int]
+    step: Optional[int]
+    raw_bytes: bytes
+
+
+class ROS2ImageDecoder:
+    def decode_message(
+        self,
+        payload: Union[str, bytes, Dict[str, Any]],
+    ) -> Optional[DecodedImageMessage]:
+
+        data = self._parse_payload(payload)
+        if data is None:
+            return None
+
+        payload_obj = self._extract_payload_obj(data)
+        if not payload_obj:
+            return None
+
+        encoding = payload_obj.get("encoding", "")
+        raw_b64 = payload_obj.get("data", "")
+        metadata = payload_obj.get("metadata", {}) or {}
+
+        if not raw_b64:
+            return None
+
+        try:
+            raw_bytes = base64.b64decode(raw_b64)
+        except Exception as exc:
+            print(f"Failed to base64-decode image payload: {exc}")
+            return None
+
+        frame = self._decode_image_bytes(
+            raw_bytes=raw_bytes,
+            payload_encoding=encoding,
+            metadata=metadata,
+        )
+
+        stamp = metadata.get("stamp", {}) or {}
+
+        return DecodedImageMessage(
+            frame=frame,
+            encoding=encoding,
+            metadata=metadata,
+            stamp_sec=stamp.get("sec"),
+            stamp_nanosec=stamp.get("nanosec"),
+            frame_id=metadata.get("frame_id"),
+            height=metadata.get("height"),
+            width=metadata.get("width"),
+            ros_encoding=metadata.get("encoding"),
+            is_bigendian=metadata.get("is_bigendian"),
+            step=metadata.get("step"),
+            raw_bytes=raw_bytes,
+        )
+
+    def _parse_payload(
+        self,
+        payload: Union[str, bytes, Dict[str, Any]],
+    ) -> Optional[Dict[str, Any]]:
+
+        if isinstance(payload, dict):
+            return payload
+
+        if isinstance(payload, bytes):
+            try:
+                payload = payload.decode("utf-8")
+            except UnicodeDecodeError as exc:
+                print(f"Failed to decode MQTT payload as UTF-8: {exc}")
+                return None
+
+        if isinstance(payload, str):
+            try:
+                return json.loads(payload)
+            except json.JSONDecodeError as exc:
+                print(f"Failed to parse JSON payload: {exc}")
+                return None
+
+        return None
+
+    def _extract_payload_obj(self, data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """
+        Supports:
+
+        1. {"_payload": {...}}
+        2. {"payload": {"_payload": {...}}}
+        3. {"payload": {...}}
+        4. {"encoding": "...", "data": "..."}
+        """
+
+        if "_payload" in data and isinstance(data["_payload"], dict):
+            return data["_payload"]
+
+        if "payload" in data and isinstance(data["payload"], dict):
+            nested = data["payload"]
+
+            if "_payload" in nested and isinstance(nested["_payload"], dict):
+                return nested["_payload"]
+
+            if "encoding" in nested and "data" in nested:
+                return nested
+
+        if "encoding" in data and "data" in data:
+            return data
+
+        return None
+
+    def _decode_image_bytes(
+        self,
+        raw_bytes: bytes,
+        payload_encoding: str,
+        metadata: Dict[str, Any],
+    ) -> Optional[np.ndarray]:
+
+        if payload_encoding in (
+            "image_jpeg_base64",
+            "image_jpg_base64",
+            "image_png_base64",
+        ):
+            arr = np.frombuffer(raw_bytes, dtype=np.uint8)
+            frame_bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+
+            if frame_bgr is None:
+                print("OpenCV failed to decode compressed image.")
+                return None
+
+            return frame_bgr
+
+        if payload_encoding == "image_raw_base64":
+            return self._decode_raw_image(raw_bytes, metadata)
+
+        print(f"Unsupported payload encoding: {payload_encoding}")
+        return None
+
+    def _decode_raw_image(
+        self,
+        raw_bytes: bytes,
+        metadata: Dict[str, Any],
+    ) -> Optional[np.ndarray]:
+
+        height = metadata.get("height")
+        width = metadata.get("width")
+        ros_encoding = metadata.get("encoding")
+        step = metadata.get("step")
+
+        if not height or not width or not ros_encoding:
+            print("Missing raw image metadata: height, width, or encoding.")
+            return None
+
+        channels_by_encoding = {
+            "mono8": 1,
+            "rgb8": 3,
+            "bgr8": 3,
+            "rgba8": 4,
+            "bgra8": 4,
+        }
+
+        channels = channels_by_encoding.get(ros_encoding)
+
+        if channels is None:
+            print(f"Unsupported raw ROS image encoding: {ros_encoding}")
+            return None
+
+        arr = np.frombuffer(raw_bytes, dtype=np.uint8)
+
+        expected_row_bytes = width * channels
+
+        if step is None:
+            step = expected_row_bytes
+
+        expected_total_bytes = height * step
+
+        if arr.size < expected_total_bytes:
+            print(
+                f"Raw image buffer too small: got {arr.size} bytes, "
+                f"expected at least {expected_total_bytes} bytes."
+            )
+            return None
+
+        arr = arr[:expected_total_bytes]
+
+        rows = arr.reshape((height, step))
+        image_data = rows[:, :expected_row_bytes]
+
+        if channels == 1:
+            return image_data.reshape((height, width))
+
+        frame = image_data.reshape((height, width, channels))
+
+        if ros_encoding == "rgb8":
+            return cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+
+        if ros_encoding == "bgr8":
+            return frame
+
+        if ros_encoding == "rgba8":
+            return cv2.cvtColor(frame, cv2.COLOR_RGBA2BGR)
+
+        if ros_encoding == "bgra8":
+            return cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR)
+
+        return None

flexCommunicator/clientLibraries/flcpy/commands/commandProcessor.py

@@ -0,0 +1,113 @@
+#**************************************************************************
+# * 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.security.security import verify_signature
+from flexCommunicator.clientLibraries.flcpy.utils.constants import *
+import threading
+import json
+class commandProcessor(object):
+    def __init__(self,name="cmdProcessor",logger=None,verbose=False):
+        """Initialize a Logger component.
+
+                Parameters
+                ----------
+                name : string
+                    name of the property components
+
+                verbose : bool
+                    component verbose execution
+
+                See Also
+                --------
+                ..
+
+                Examples
+                --------
+                >> cmdProcessor = commandProcessor(name="customProcessor",verbose=False)
+
+                """
+
+        # --- logger configuration ---
+        self._name = name
+        self._verbose = verbose
+        self._logger = logger
+        # Set to store received command IDs.
+        self._received_command_ids = set()
+        self._command_ids_lock = threading.Lock()
+
+        self._logger.info("Command processor initialized")
+
+
+    def process_command(self,command):
+        """Process a command """
+        action = None
+        data = {}
+
+        # DECODE INCOMMING COMMAND
+        try:
+            command = json.loads(command)
+        except:
+            command = GENERIC_STATUS.INCORRECT_CMD
+
+        # CHECK COMMAND CORRECTNESS (SIGNATURE)
+        signature_valid = verify_signature(command=command)
+
+        try:
+            #CHECK IF COMMAND IS ALREADY RECEIVED
+            if not self.is_command_already_received(command):
+                if command["cmd"] == FLEXCLOUD_COMMANDS.UNKNOWN:
+                    if self._logger is not None: self._logger.error(COMMAND_TYPE.UNKNOWN+" command received. Please verify the command type")
+                    return action,data
+                elif command["cmd"] == FLEXCLOUD_COMMANDS.PING:
+                    if self._logger is not None: self._logger.info(COMMAND_TYPE.PING+" command received.")
+                    if self._verbose: print(FLEXCLOUD_COMMANDS.PING+" command received.")
+                    action = FLEXCLOUD_COMMANDS.PING
+                    data = {}
+                    return signature_valid,action,data
+                elif command["cmd"] == FLEXCLOUD_COMMANDS.UPDATE_TRANSPORT:
+                    if self._logger is not None: self._logger.info(FLEXCLOUD_COMMANDS.UPDATE_TRANSPORT+" command received.")
+                    if self._verbose: print(FLEXCLOUD_COMMANDS.UPDATE_TRANSPORT+" command received.")
+                    action = FLEXCLOUD_COMMANDS.UPDATE_TRANSPORT
+                    data = command["params"]
+                    return signature_valid,action,data
+                else:
+                    if self._logger is not None: self._logger.warning(FLEXCLOUD_WARNINGS.WARN_UNKNOWN_FLEXCLOUD_COMMAND)
+                    return signature_valid,action,data
+
+                #TODO: extend with other accepted commands
+
+        except Exception as e:
+            if self._logger is not None: self._logger.error("Failed to process command.")
+
+
+    def is_command_already_received(self,command):
+        """
+        Checks if a command has already been received by inspecting its unique 'id' field.
+
+        This function uses a global set to keep track of command IDs that have already been processed.
+        If the command has not been received before, its ID is added to the set.
+
+        Args:
+            command (dict): The command dictionary. Must include an 'id' key.
+
+        Returns:
+            bool: True if the command was already received, False if it is new.
+
+        Raises:
+            ValueError: If the command does not contain an 'id' field.
+        """
+        command_id = command.get("id")
+        if command_id is None:
+            raise ValueError("Command does not contain an 'id' field.")
+
+        with self._command_ids_lock:
+            if command_id in self._received_command_ids:
+                return True
+            else:
+                self._received_command_ids.add(command_id)
+                return False

flexCommunicator/clientLibraries/flcpy/commands/composer.py

@@ -0,0 +1,25 @@
+#**************************************************************************
+# * 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 uuid
+from flexCommunicator.clientLibraries.flcpy.security.security import *
+def compose_command(cmd_type, params, priority=5, expiry_seconds=60):
+    current_time = int(time.time())
+
+    _command = {
+        "id": str(uuid.uuid4()),
+        "cmd": cmd_type,
+        "priority": priority,                # Add command priority (e.g., 1=highest, 10=lowest)
+        "expiry": current_time + expiry_seconds,  # Command expiry timestamp
+        "params": params,
+        "timestamp": current_time,
+        "nonce": uuid.uuid4().hex
+    }
+    _command["signature"] = compute_signature(_command)
+    return _command