fred-oss 0.7.0__tar.gz → 0.9.0__tar.gz

{fred_oss-0.7.0/src/main/fred_oss.egg-info → fred_oss-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.7.0
+Version: 0.9.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.7.0 → fred_oss-0.9.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.9.0/src/main/fred/version

@@ -0,0 +1 @@
+0.9.0

fred_oss-0.9.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.9.0/src/main/fred/worker/runner/client.py

@@ -0,0 +1,101 @@
+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)),
+            "db": int(kwargs.get("db") or get_environ_variable(name="REDIS_DB", default=0)),
+        }
+        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.9.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.7.0 → fred_oss-0.9.0/src/main/fred_oss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.7.0
+Version: 0.9.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.7.0 → fred_oss-0.9.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -27,6 +27,9 @@ 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/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
 src/main/fred_oss.egg-info/dependency_links.txt

{fred_oss-0.7.0 → fred_oss-0.9.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.7.0/src/main/fred/version

@@ -1 +0,0 @@
-0.7.0