fred-oss 0.36.0__tar.gz → 0.38.0__tar.gz

{fred_oss-0.36.0/src/main/fred_oss.egg-info → fred_oss-0.38.0}/PKG-INFO

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

{fred_oss-0.36.0 → fred_oss-0.38.0}/src/main/fred/future/impl.py

@@ -62,6 +62,7 @@ class Future(MonadInterface[A]):
             function: Callable[..., A],
             on_start: Optional[CallbackInterface] = None,
             on_complete: Optional[CallbackInterface] = None,
+            parent_id: Optional[str] = None,
             **kwargs
         ):
         """Initializes a Future with the provided function to be executed asynchronously.
@@ -76,11 +77,12 @@ class Future(MonadInterface[A]):
                 All keyword arguments except 'future_id' are forwarded to the target function.
         """
         # Create a new available future
-        future = FutureUndefinedPending.auto(future_id=kwargs.pop("future_id", None))
+        future = FutureUndefinedPending.auto(parent_id=parent_id, future_id=kwargs.pop("future_id", None))
         # Register the Future-ID and define the available future via the provided function.
         # Note: The 'apply' method is blocking by itself; thus, we run it in a separate thread.
         # Note: The thread is a daemon to ensure it does not block program exit.
         self.future_id = future.future_id
+        self.parent_id = parent_id
         self.thread = Thread(
             target=lambda: future.apply(
                 function=function,
@@ -220,6 +222,7 @@ class Future(MonadInterface[A]):
             Future[B]: A new Future representing the chained operation."""
         # TODO: Is there a more efficient implementation?
         return Future(
+            parent_id=self.future_id,
             function=lambda:
                 function(self.wait_and_resolve(timeout=timeout))
                 .wait_and_resolve(timeout=timeout)
@@ -228,12 +231,23 @@ class Future(MonadInterface[A]):
     def map(self, function: Callable[[A], B]) -> 'Future[B]':
         """Applies a function to the result of the future, returning a new future.
         This method allows for transforming the result of a future without blocking.
+
+        Original implementation:
+        return self.flat_map(function=lambda value: type(self).from_value(function(value)))
+
+        However, that implementation would create an intermediate Future just to
+        hold the transformed value, which is unnecessary overhead. Instead, we can directly create a new Future
+        that applies the transformation function to the result of the current future.
+
         Args:
             function (Callable[[A], B]): A function that takes the result of the current future
                                           and returns a new value.
         Returns: Future[B]: A new Future containing the transformed result.
         """
-        return self.flat_map(function=lambda value: type(self).from_value(function(value)))
+        return Future(
+            function=lambda: function(self.wait_and_resolve()),
+            parent_id=self.future_id,
+        )
 
     @classmethod
     def pullsync(
@@ -275,3 +289,20 @@ class Future(MonadInterface[A]):
             on_complete=on_complete,
             **kwargs
         )
+    def lineage(self) -> list[str]:
+        """Retrieves the lineage of the future, tracing back through its parent futures.
+        This method is useful for debugging and understanding the sequence of computations
+        that led to the current future.
+        Returns:
+            list[str]: A list of future IDs representing the lineage, starting from the current future
+                       and tracing back through its parents.
+        """
+        logger.warning(
+            "The 'lineage' method should only be used for debugging purposes "
+            "as it may have performance implications and unreliable lineage due to "
+            "possible missing parent_id values caused by cleanup or TTL expiration."
+        )
+        if not (fr := FutureResult.from_backend(future_id=self.future_id)):
+            logger.error(f"Current future_id '{self.future_id}' does not exist in backend.")
+            return []
+        return fr._lineage()

{fred_oss-0.36.0 → fred_oss-0.38.0}/src/main/fred/future/result.py

@@ -79,6 +79,7 @@ class FutureResult(Generic[A], FutureBackend.infer_backend()):
     It uses a key-value store to persist the state and result of the Future, allowing for
     retrieval and management of asynchronous tasks."""
     future_id: str
+    parent_id: Optional[str]
 
     @staticmethod
     def _get_future_keyname(future_id: str) -> str:
@@ -131,7 +132,24 @@ class FutureResult(Generic[A], FutureBackend.infer_backend()):
 
     @classmethod
     def from_backend(cls, future_id: str) -> Optional['FutureResult[A]']:
-        return FutureResult(future_id=future_id)._from_backend()
+        return FutureResult(future_id=future_id, parent_id=None)._from_backend()
+
+    @property
+    def _pre(self) -> Optional['FutureResult']:
+        if not self.parent_id:
+            return None
+        return FutureResult.from_backend(future_id=self.parent_id)
+
+    def _lineage(self) -> list[str]:
+        if not self.parent_id:
+            return [self.future_id]
+        if not (parent := self._pre):
+            logger.warning(
+                f"Cannot retrieve full lineage for Future[{self.future_id}] "
+                f"due to missing parent_id '{self.parent_id}'"
+            )
+            return [self.future_id, self.parent_id]
+        return [self.future_id, *parent._lineage()]
 
 
 @dataclass(frozen=True, slots=False)
@@ -149,8 +167,9 @@ class FutureUndefinedPending(FutureResult[A]):
             FutureUndefinedPending[A]: A new instance of FutureUndefinedPending with a unique future_id.
         """
         import uuid
+        parent_id = kwargs.pop("parent_id", None)
         future_id = kwargs.pop("future_id", None) or str(uuid.uuid4())
-        return FutureUndefinedPending[A](future_id=future_id, **kwargs)
+        return FutureUndefinedPending[A](future_id=future_id, parent_id=parent_id, **kwargs)
 
     def __post_init__(self):
         logger.debug(f"Future[{self.future_id}] initialized and pending execution")
@@ -183,6 +202,7 @@ class FutureUndefinedPending(FutureResult[A]):
         """
         fip = FutureUndefinedInProgress[A](
             future_id=self.future_id,
+            parent_id=self.parent_id,
             started_at=perf_counter(),
             function_name=function.__name__,
         )
@@ -257,6 +277,7 @@ class FutureUndefinedInProgress(FutureResult[A]):
                 raise e
         future_defined = FutureDefined(
             future_id=self.future_id,
+            parent_id=self.parent_id,
             value=value,
             ok=ok,
         )

fred_oss-0.38.0/src/main/fred/version

@@ -0,0 +1 @@
+0.38.0

{fred_oss-0.36.0 → fred_oss-0.38.0/src/main/fred_oss.egg-info}/PKG-INFO

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

fred_oss-0.36.0/src/main/fred/version

@@ -1 +0,0 @@
-0.36.0