fred-oss 0.44.0__tar.gz → 0.46.0__tar.gz

{fred_oss-0.44.0/src/main/fred_oss.egg-info → fred_oss-0.46.0}/PKG-INFO

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

{fred_oss-0.44.0 → fred_oss-0.46.0}/src/main/fred/future/impl.py

@@ -1,3 +1,4 @@
+import time
 from threading import Thread
 from typing import (
     Callable,
@@ -204,8 +205,22 @@ class Future(MonadInterface[A]):
         return self.wait(timeout=timeout).resolve()
 
     @classmethod
-    def from_value(cls, val: A) -> 'Future[A]':
-        return Future(function=lambda: val)
+    def from_value(cls, val: A, **kwargs) -> 'Future[A]':
+        """
+        Creates a Future that is immediately resolved with the given value.
+
+        Args:
+            val (A): The value to resolve the Future with.
+            **kwargs: Additional keyword arguments forwarded to the Future constructor.
+                These may include parameters such as:
+                    - parent_id (Optional[str]): The parent future's ID.
+                    - expiration (Optional[float]): Expiration time for the future.
+                    - callback (Optional[CallbackInterface]): Callback to invoke on completion.
+                For a full list of accepted parameters, see the Future class documentation.
+        Returns:
+            Future[A]: A Future instance resolved with the provided value.
+        """
+        return Future(function=lambda: val, **kwargs)
     
     def flat_map(self, function: Callable[[A], 'Future[B]'], timeout: Optional[float] = None) -> 'Future[B]':
         """Chains the current future with another future-producing function.
@@ -305,6 +320,8 @@ class Future(MonadInterface[A]):
             future_id: str,
             on_start: Optional[CallbackInterface] = None,
             on_complete: Optional[CallbackInterface] = None,
+            retry_delay: float = 0.2,
+            retry: int = 3,
     ) -> 'Future[A]':
         """Subscribes to updates for an existing future using a publish-subscribe mechanism.
         This method allows for receiving real-time updates about the future's state
@@ -318,9 +335,13 @@ class Future(MonadInterface[A]):
         Returns:
             Future[A]: A Future instance that will execute the subscription logic.
         """
+        # TODO: Consider adding a timeout parameter to avoid waiting indefinitely...
+        # TODO: There's a known issue where if the future completes before we subscribe,
+        #       we might miss the completion message.
         # Define a closure that will handle incoming messages from the pub-sub channel
         def closure():
             for payload in FutureResult._get_bcast_channel(future_id=future_id).subscribe():
+                logger.info(f"Received pubsub message for future '{future_id}': {payload}")
                 if payload.get("type") != "message":
                     continue
                 message = payload.get("data")
@@ -352,11 +373,22 @@ class Future(MonadInterface[A]):
             case instance:
                 # The future-result can be None if the future_id does not exist
                 if not instance:
-                    raise ValueError(f"Future with ID '{future_id}' does not exist.")
+                    if retry <= 0:
+                        raise ValueError(f"Future with ID '{future_id}' does not exist.")
+                    logger.error(f"Future with ID '{future_id}' does not exist; attempting to retry ({retry} retries left).")
+                    time.sleep(retry_delay)
+                    return cls.subscribe(
+                        future_id=future_id,
+                        on_start=on_start,
+                        on_complete=on_complete,
+                        retry_delay=retry_delay,
+                        retry=max(0, retry - 1),
+                    )
                 # If the future exists, but is not configured for broadcast, raise an error...
                 if not instance.broadcast:
                     raise ValueError("Future is not configured for broadcast; cannot subscribe.")
                 # If the future exists and is configured for broadcast, subscribe to updates...
+                logger.info(f"Subscribing to future '{future_id}' via broadcast channel.")
                 return cls(
                     function=closure,
                     **shared_params

{fred_oss-0.44.0 → fred_oss-0.46.0}/src/main/fred/future/result.py

@@ -107,7 +107,6 @@ class FutureResult(Generic[A], FutureBackend.infer_backend()):
             self.bcast_channel.publish(item=item or self.stringify())
             return True
         return False
-        
 
     @classmethod
     def _get_status_key(cls, future_id: str) -> FredKeyVal:

fred_oss-0.46.0/src/main/fred/version

@@ -0,0 +1 @@
+0.46.0

{fred_oss-0.44.0 → fred_oss-0.46.0}/src/main/fred/worker/interface.py

@@ -2,6 +2,7 @@ import time
 from typing import overload, Callable, Optional
 from dataclasses import dataclass, field
 
+from fred.worker.settings import FRD_WORKER_DEFAULT_BROADCAST
 from fred.future.impl import Future  # Should we make this import lazy?
 from fred.utils.dateops import datetime_utcnow
 from fred.settings import (
@@ -139,14 +140,14 @@ class HandlerInterface:
         return json.loads(metadata_serialized)
 
     @overload
-    def run(self, event: dict, as_future: bool = True, future_id: Optional[str] = None) -> Future[dict]:
+    def run(self, event: dict, as_future: bool = True, broadcast: Optional[bool] = None, future_id: Optional[str] = None) -> Future[dict]:
         ...
 
     @overload
-    def run(self, event: dict, as_future: bool = False, future_id: Optional[str] = None) -> dict:
+    def run(self, event: dict, as_future: bool = False, broadcast: Optional[bool] = None, future_id: Optional[str] = None) -> dict:
         ...
 
-    def run(self, event: dict, as_future: bool = False, future_id: Optional[str] = None) -> dict | Future[dict]:
+    def run(self, event: dict, as_future: bool = False, broadcast: Optional[bool] = None, future_id: Optional[str] = None) -> dict | Future[dict]:
         """Process an incoming event and return a structured response.
         The event is expected to be a dictionary with at least an 'id' and 'input' keys.
         The 'input' key should contain the payload to be processed.
@@ -158,7 +159,11 @@ class HandlerInterface:
                 If requested as a Future, returns a Future that will resolve to the response dictionary.
         """
         if as_future:
-            return Future(function=lambda: self.run(event=event, as_future=False), future_id=future_id)
+            return Future(
+                future_id=future_id,
+                function=lambda: self.run(event=event, as_future=False),
+                broadcast=FRD_WORKER_DEFAULT_BROADCAST if broadcast is None else broadcast,
+            )
         # Extract payload and event ID
         payload = event.get("input", {})
         job_event_identifier = event.get("id")

{fred_oss-0.44.0 → fred_oss-0.46.0}/src/main/fred/worker/runner/client.py

@@ -124,6 +124,10 @@ class RunnerClient:
             retry_backoff_rate: float = 0.1,
             **kwargs,
     ) -> Future:
+        logger.warning(
+            "Using 'pullsync' is to be deprecated soon; use the 'Future.subscribe' "
+            "method instead (by default this is used on fetch_result with 'use_pullsync=False')."
+        )
         return Future(
             function=self._pullsync,
             request_id=request_id,
@@ -160,8 +164,16 @@ class RunnerClient:
                 return False
         return True
 
-    def fetch_result(self, request_id: str, now: bool = False, timeout: Optional[float] = None, **kwargs) -> Optional[dict]:
-        future = self.pullsync(request_id=request_id, **kwargs)
+    def fetch_result(
+            self,
+            request_id: str,
+            now: bool = False,
+            timeout: Optional[float] = None,
+            use_pullsync: bool = False,
+            **kwargs,
+    ) -> Optional[dict]:
+        future = self.pullsync(request_id=request_id, **kwargs) \
+            if use_pullsync else Future.subscribe(future_id=request_id, **kwargs)
         if now:
             return future.getwhatevernow()
         return future.wait_and_resolve(timeout=timeout)

fred_oss-0.46.0/src/main/fred/worker/settings.py

@@ -0,0 +1,7 @@
+from fred.settings import get_environ_variable
+
+
+FRD_WORKER_DEFAULT_BROADCAST = bool(int(get_environ_variable(
+    name="FRD_WORKER_BROADCAST_DEFAULT",
+    default="0",
+)) or 0)

{fred_oss-0.44.0 → fred_oss-0.46.0/src/main/fred_oss.egg-info}/PKG-INFO

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

{fred_oss-0.44.0 → fred_oss-0.46.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ 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/settings.py
 src/main/fred/worker/runner/__init__.py
 src/main/fred/worker/runner/backend.py
 src/main/fred/worker/runner/client.py

fred_oss-0.44.0/src/main/fred/version

@@ -1 +0,0 @@
-0.44.0