fred-oss 0.8.0__tar.gz → 0.10.0__tar.gz

{fred_oss-0.8.0/src/main/fred_oss.egg-info → fred_oss-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.8.0
+Version: 0.10.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development

fred_oss-0.10.0/src/main/fred/version

@@ -0,0 +1 @@
+0.10.0

fred_oss-0.10.0/src/main/fred/worker/runner/client.py

@@ -0,0 +1,104 @@
+import uuid
+import json
+from dataclasses import dataclass
+
+from fred.settings import (
+    get_environ_variable,
+    logger_manager,
+)
+
+from redis import Redis
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerClient:
+    instance: Redis
+    req_queue: str
+    res_queue: str
+
+    @classmethod
+    def auto(cls, **kwargs) -> "RunnerClient":
+        redis_configs = {
+            "host": kwargs.get("host") or get_environ_variable(name="REDIS_HOST", default="localhost"),
+            "port": int(kwargs.get("port") or get_environ_variable(name="REDIS_PORT", default=6379)),
+            "password": get_environ_variable(name="REDIS_PASSWORD", default=None),
+            "db": int(kwargs.get("db") or get_environ_variable(name="REDIS_DB", default=0)),
+            "decode_responses": True,
+            **kwargs.pop("redis_configs", {}),
+        }
+        redis_instance = Redis(**redis_configs)
+        req_queue = kwargs.get("request_queue") or get_environ_variable(name="FRD_RUNNER_REQUEST_QUEUE", default=None) or (
+            logger.warning("Redis request queue not specified; defaulting to 'req:demo'.") or "req:demo"
+        )
+        res_queue = kwargs.get("response_queue") or get_environ_variable(name="FRD_RUNNER_RESPONSE_QUEUE", default=None) or (
+            logger.warning("Redis response queue not specified; defaulting to inferring pattern.") or f"res:{req_queue.split(':')[-1]}"
+        )
+        logger.info(f"Connecting to Redis, using request queue '{req_queue}' and response queue '{res_queue}'.")
+        return cls(
+            instance=redis_instance,
+            req_queue=req_queue,
+            res_queue=res_queue,
+        )
+
+    @property
+    def PING(self):
+        return self.signal("PING")
+
+    @property
+    def STOP(self):
+        return self.signal("STOP")
+
+    def signal(self, signal: str):
+        # TODO: Validate signals via enum
+        self.instance.lpush(self.req_queue, signal)
+
+    def send(self, item: dict, uuid_hash: bool = False) -> str:
+        item_id = item.get("item_id")
+        item_str = json.dumps(item)
+        if not item_id:
+            logger.warning("Item does not have 'item_id'; assigning a UUID based on the hash.")
+            item["item_id"] = item_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, item_str)) \
+                if uuid_hash else str(uuid.uuid4())
+            item_str = json.dumps(item)
+        self.instance.lpush(self.req_queue, item_str)
+        self.instance.set(f"item_status:{item_id}", "IN_QUEUE")
+        return item_id
+    
+    def fetch_status(self, item_id: str) -> str | None:
+        status_raw = self.instance.get(f"item_status:{item_id}")
+        if not status_raw:
+            logger.info(f"No status found for item_id '{item_id}'.")
+            return None
+        return status_raw.decode("utf-8")
+
+    def fetch_result(self, item_id: str, blocking: bool = False) -> dict | None:
+        match self.fetch_status(item_id=item_id):
+            case None:
+                logger.info(f"No status found for item_id '{item_id}'.")
+                return None
+            case "IN_QUEUE" | "PROCESSING":
+                if blocking:
+                    logger.info(f"Blocking until item '{item_id}' is completed.")
+                    while (status := self.fetch_status(item_id=item_id)) in ("IN_QUEUE", "PROCESSING"):
+                        continue
+                else:
+                    logger.info(f"Item '{item_id}' is still in progress (current status: '{self.fetch_status(item_id=item_id)}').")
+                    return None
+            case "FAILED":
+                logger.error(f"Item '{item_id}' processing failed.")
+                return None
+            case "COMPLETED":
+                result_raw = self.instance.get(f"item_output:{item_id}")
+                if result_raw:
+                    try:
+                        return json.loads(result_raw)
+                    except json.JSONDecodeError as e:
+                        logger.error(f"Error decoding JSON result for item_id '{item_id}': {e}")
+                        return None
+                else:
+                    logger.error(f"No result found for item_id '{item_id}'.")
+                    return None
+            case status:
+                logger.warning(f"Item '{item_id}' has unrecognized status '{status}'. Proceeding to fetch result.")

{fred_oss-0.8.0 → fred_oss-0.10.0}/src/main/fred/worker/runner/handler.py

@@ -27,14 +27,14 @@ class RunnerHandler(HandlerInterface):
         lifespan = payload.get("lifetime", 3600)  # Default to 1 hour if not specified
         timeout = payload.get("timeout", 30)  # Default to 30 seconds if not specified
         # Get Redis connection details from payload or environment variables
-        redis_configs = payload.pop(
-            "redis_configs",
-            {
-                "host": get_environ_variable(name="REDIS_HOST", default="localhost"),
-                "port": int(get_environ_variable(name="REDIS_PORT", default=6379)),
-                "db": int(get_environ_variable(name="REDIS_DB", default=0)),
-            }
-        )
+        redis_configs = {
+            "host": get_environ_variable(name="REDIS_HOST", default="localhost"),
+            "port": int(get_environ_variable(name="REDIS_PORT", default=6379)),
+            "password": get_environ_variable(name="REDIS_PASSWORD", default=None),
+            "db": int(get_environ_variable(name="REDIS_DB", default=0)),
+            "decode_responses": True,
+            **payload.pop("redis_configs", {}),
+        }
         # Connect to Redis
         redis = Redis(**redis_configs)
         req_queue = payload.pop("redis_request_queue", None) or get_environ_variable(name="FRD_RUNNER_REQUEST_QUEUE", default=None) or (
@@ -64,16 +64,16 @@ class RunnerHandler(HandlerInterface):
                 break
             # Fetch item from Redis queue 
             try:
-                item_raw = redis.rpop(req_queue)
+                item_str = redis.rpop(req_queue)
             except Exception as e:
                 logger.error(f"Error fetching item from Redis queue '{req_queue}': {e}")
                 continue
             # If no item, iterate again
-            if not item_raw:
+            if not item_str:
                 continue
             try:
                 # Handle special signals
-                match (item_str := item_raw.decode("utf-8")):
+                match item_str:
                     case "STOP" | "SHUTDOWN" | "TERMINATE":
                         logger.info("Received STOP signal; exiting runner loop.")
                         break

{fred_oss-0.8.0 → fred_oss-0.10.0/src/main/fred_oss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.8.0
+Version: 0.10.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development

{fred_oss-0.8.0 → fred_oss-0.10.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ src/main/fred/utils/runtime.py
 src/main/fred/worker/__init__.py
 src/main/fred/worker/interface.py
 src/main/fred/worker/runner/__init__.py
+src/main/fred/worker/runner/client.py
 src/main/fred/worker/runner/handler.py
 src/main/fred_oss.egg-info/PKG-INFO
 src/main/fred_oss.egg-info/SOURCES.txt

fred_oss-0.8.0/src/main/fred/version

@@ -1 +0,0 @@
-0.8.0