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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.6.0
+Version: 0.8.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development
@@ -10,6 +10,7 @@ Description-Content-Type: text/markdown
 License-File: NOTICE.txt
 Requires-Dist: fire==0.7.1
 Requires-Dist: psutil==7.0.0
+Requires-Dist: redis==6.4.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{fred_oss-0.6.0 → fred_oss-0.8.0}/requirements.txt

@@ -2,4 +2,6 @@
 fire==0.7.1
 # Minimal requirements
 psutil==7.0.0
+# Fred Workers Infra
+redis==6.4.0
 # Databricks Runtime: 16.4 LTS (Python 3.12.3)

fred_oss-0.8.0/src/main/fred/version

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

{fred_oss-0.6.0 → fred_oss-0.8.0}/src/main/fred/worker/interface.py

@@ -157,6 +157,13 @@ class HandlerInterface:
         ok = True
         response = None
         # Determine action based on 'fred_worker_action' in payload
+        propagate_worker_error = int(payload.pop(
+            "propagate_worker_error",
+            get_environ_variable(
+                "FRD_PROPAGATE_WORKER_ERROR",
+                default="0"
+            )
+        ))
         match (worker_action := payload.pop("fred_worker_action", "handler")):
             case "telemetry":
                 # Collect and return telemetry data
@@ -170,6 +177,8 @@ class HandlerInterface:
                 except Exception as e:
                     ok = False
                     logger.error(f"Error processing handler for event {job_event_identifier}: {e}")
+                    if propagate_worker_error:
+                        raise
                     response = {
                         "error": str(e)
                     }
@@ -188,17 +197,24 @@ class HandlerInterface:
                         except Exception as e:
                             ok = False
                             logger.error(f"Error processing custom action '{action}' for event {job_event_identifier}: {e}")
+                            if propagate_worker_error:
+                                raise
                             response = {
                                 "error": str(e)
                             }
                     case _:
                         ok = False
+                        logger.error(f"Custom action '{action}' is not callable.")
+                        if propagate_worker_error:
+                            raise ValueError(f"Custom action '{action}' is not callable.")
                         response = {
                             "error": f"Custom action '{action}' is not callable."
                         }
             case _:
                 # Handle invalid action types
                 logger.error(f"Invalid fred_worker_action type received: {type(worker_action)}")
+                if propagate_worker_error:
+                    raise ValueError("Invalid fred_worker_action type.")
                 ok = False
                 response = {
                     "error": "Invalid fred_worker_action type."

fred_oss-0.8.0/src/main/fred/worker/runner/__init__.py

@@ -0,0 +1,11 @@
+from fred.maturity import Maturity, MaturityLevel
+
+
+module_maturity = Maturity(
+    level=MaturityLevel.ALPHA,
+    reference=__name__,
+    message=(
+        "Fred-Worker Redis Runners implementation is in early development "
+        "and therefore currently with incomplete and unstable features."
+    )
+)

fred_oss-0.8.0/src/main/fred/worker/runner/handler.py

@@ -0,0 +1,136 @@
+import uuid
+import json
+from dataclasses import dataclass
+
+from fred.utils.dateops import datetime_utcnow
+from fred.worker.interface import HandlerInterface
+from fred.settings import (
+    get_environ_variable,
+    logger_manager,
+)
+
+from redis import Redis
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=False)
+class RunnerHandler(HandlerInterface):
+    
+    def __post_init__(self):
+        super().__post_init__()
+        logger.info("Runpod Handler initialized using Fred-Worker interface.")
+
+    def handler(self, payload: dict) -> dict:
+        # TODO: Breakdown the handler logic into smaller methods for better readability and testing
+        # E.g., loop method, process item method, signal handling method, etc.
+        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)),
+            }
+        )
+        # 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 (
+            logger.warning("Redis request queue not specified; defaulting to: 'req:demo'") or "req:demo"
+        )
+        res_queue = payload.pop("redis_response_queue", None) or get_environ_variable(name="FRD_RUNNER_RESPONSE_QUEUE", default=None) or (
+            logger.warning("Redis response queue not specified; defaulting to: None (not using response queue)") or None
+        )
+        # Handoff to target handler (i.e., runner)
+        runner_configs = payload.pop("runner_configs")
+        runner_id = runner_configs.pop("id", str(uuid.uuid4()))
+        runner = HandlerInterface.find_handler(**runner_configs)
+        logger.info(f"Runpod Redis Handler started with runner '{runner_id}' listening to Redis queue: '{req_queue}'")
+        redis.set(f"runner_status:{runner_id}", "RUNNING")
+        redis.set(f"runner_created_at:{runner_id}", datetime_utcnow().isoformat())
+        # Main runner loop to process items from Redis queue
+        # TODO: Can we make this main-loop concurrent with threads or async?
+        # TODO: Consider collecting metrics (e.g., processing time per item, total items processed, errors, etc.) and stats
+        start_time = datetime_utcnow()
+        last_processed_time = datetime_utcnow()
+        while (elapsed_seconds := (datetime_utcnow() - start_time).total_seconds()):
+            if elapsed_seconds > lifespan:
+                logger.info("Lifespan exceeded; exiting runner loop.")
+                break
+            if (idle_seconds := (datetime_utcnow() - last_processed_time).total_seconds()) > timeout:
+                logger.info(f"Idle time ({idle_seconds}) exceeded timeout ({timeout}); exiting runner loop.")
+                break
+            # Fetch item from Redis queue 
+            try:
+                item_raw = 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:
+                continue
+            try:
+                # Handle special signals
+                match (item_str := item_raw.decode("utf-8")):
+                    case "STOP" | "SHUTDOWN" | "TERMINATE":
+                        logger.info("Received STOP signal; exiting runner loop.")
+                        break
+                    case "PING":
+                        logger.info("Received PING signal; continuing.")
+                        last_processed_time = datetime_utcnow()
+                        continue
+                    case _:
+                        pass
+                # Parse item payload and extract item_id
+                item_payload = json.loads(item_str)
+                item_id = item_payload.pop("item_id") or (
+                    logger.warning("No item_id provided in payload; generating a new one using UUID5.")
+                    or str(uuid.uuid5(uuid.NAMESPACE_OID, item_str))
+                )
+            except Exception as e:
+                logger.error(f"Error decoding or parsing item from Redis: {e}")
+                continue
+            logger.info(f"Processing item with ID: {item_id}")      
+            redis.set(f"item_status:{item_id}", "IN_PROGRESS")
+            try:
+                out_payload = runner.run(
+                    event={
+                        "id": item_id,
+                        "input": item_payload
+                    }
+                )
+                out_str = json.dumps(out_payload) if isinstance(out_payload, dict) else str(out_payload)
+                redis.set(f"item_status:{item_id}", "COMPLETED")
+                # TODO: Consider adding a TTL to the result keys (e.g., 24 hours)
+                redis.set(f"item_output:{item_id}", out_str)
+                if res_queue:
+                    redis.lpush(res_queue, out_str) 
+            except Exception as e:
+                logger.error(f"Error processing item with ID {item_id}: {e}")
+                redis.set(f"item_status:{item_id}", "FAILED")
+                redis.set(f"item_output:{item_id}", str(e))
+                continue
+            logger.info(f"Processed item with ID: {item_id}")
+            last_processed_time = datetime_utcnow()
+        redis.set(f"runner_status:{runner_id}", "STOPPED")
+        pending_requests = redis.llen(req_queue)
+        if pending_requests:
+            logger.warning(f"Runner '{runner_id}' stopped with {pending_requests} pending items still in the queue '{req_queue}'.")
+            # TODO: Consider adding logic (optional/configurable) to spin up a new runner to handle pending items or notify runner-manager
+        else:
+            logger.info("Runner stopped with no pending items in the queue.")
+        return {
+            "status": "completed",
+            "runner_id": runner_id,
+            "processed_at": datetime_utcnow().isoformat(),
+            "total_elapsed_seconds": (datetime_utcnow() - start_time).total_seconds(),
+            "last_processed_at": last_processed_time.isoformat(),
+            "idle_seconds": (datetime_utcnow() - last_processed_time).total_seconds(),
+            "pending_requests": pending_requests,
+            "request_queue": req_queue,
+            "response_queue": res_queue,
+            "lifespan_seconds": lifespan,
+            "timeout_seconds": timeout,
+        }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.6.0
+Version: 0.8.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development
@@ -10,6 +10,7 @@ Description-Content-Type: text/markdown
 License-File: NOTICE.txt
 Requires-Dist: fire==0.7.1
 Requires-Dist: psutil==7.0.0
+Requires-Dist: redis==6.4.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

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

@@ -27,6 +27,8 @@ src/main/fred/utils/dateops.py
 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/handler.py
 src/main/fred_oss.egg-info/PKG-INFO
 src/main/fred_oss.egg-info/SOURCES.txt
 src/main/fred_oss.egg-info/dependency_links.txt

{fred_oss-0.6.0 → fred_oss-0.8.0}/src/main/fred_oss.egg-info/requires.txt

@@ -1,2 +1,3 @@
 fire==0.7.1
 psutil==7.0.0
+redis==6.4.0

fred_oss-0.6.0/src/main/fred/version

@@ -1 +0,0 @@
-0.6.0