fred-oss 0.22.0__tar.gz → 0.24.0__tar.gz

{fred_oss-0.22.0/src/main/fred_oss.egg-info → fred_oss-0.24.0}/PKG-INFO

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

fred_oss-0.24.0/src/main/fred/future/callback/_function.py

@@ -0,0 +1,19 @@
+from typing import (
+    Callable,
+    TypeVar,
+)
+
+from fred.future.callback.interface import CallbackInterface
+from fred.monad.catalog import EitherMonad
+
+A = TypeVar("A")
+
+
+class CallbackFunction(CallbackInterface[A]):
+    
+    def __init__(self, function: Callable[[EitherMonad.Either[A]], None], **kwargs):
+        self.function = function
+        self.kwargs = kwargs
+
+    def execute(self, output: EitherMonad.Either[A]):
+        self.function(output, **self.kwargs)

fred_oss-0.24.0/src/main/fred/future/callback/catalog.py

@@ -0,0 +1,12 @@
+import enum
+
+from fred.future.callback.interface import CallbackInterface
+from fred.future.callback._function import CallbackFunction
+
+
+
+class CallbackCatalog(enum.Enum):
+    FUNCTION = CallbackFunction
+
+    def __call__(self, *args, **kwargs) -> CallbackInterface:
+        return self.value(*args, **kwargs)

fred_oss-0.24.0/src/main/fred/future/callback/interface.py

@@ -0,0 +1,33 @@
+from typing import (
+    Generic,
+    TypeVar,
+)
+
+from fred.settings import logger_manager
+from fred.monad.catalog import EitherMonad
+
+logger = logger_manager.get_logger(__name__)
+
+A = TypeVar("A")
+
+
+class CallbackInterface(Generic[A]):
+    
+    def execute(self, output: EitherMonad.Either[A]):
+        raise NotImplementedError()
+    
+    def run(self, output: EitherMonad.Either[A]) -> bool:
+        """Executes the callback with the provided output and handles any exceptions.
+        Args:
+            output (EitherMonad.Either[A]): The output to be passed to the callback.
+        Returns:
+            bool: True if the callback executed successfully, False otherwise.
+        """
+        # TODO: Consider using a richer return type to capture more details about the execution
+        #  and optionally propagate the callback return value.
+        try:
+            self.execute(output=output)
+            return True
+        except Exception as e:
+            logger.error(f"Callback execution failed: {e}")
+            return False

{fred_oss-0.22.0 → fred_oss-0.24.0}/src/main/fred/future/impl.py

@@ -6,6 +6,7 @@ from typing import (
 )
 
 from fred.settings import logger_manager
+from fred.future.callback.interface import CallbackInterface
 from fred.monad.interface import MonadInterface
 from fred.monad.catalog import EitherMonad
 from fred.future.result import (
@@ -55,21 +56,35 @@ class Future(MonadInterface[A]):
     TODO: Consider using more advanced concurrency primitives for better control and efficiency.
     """
 
-    def __init__(self, function: Callable[..., A], **kwargs):
+    def __init__(
+            self,
+            function: Callable[..., A],
+            on_complete: Optional[CallbackInterface] = None,
+            **kwargs
+        ):
         """Initializes a Future with the provided function to be executed asynchronously.
         The function is executed in a separate thread, allowing for non-blocking operations.
+
         Args:
             function (Callable[..., A]): The function to be executed asynchronously.
+            future_id (Optional[str], keyword-only): A reserved keyword-only parameter used to
+                uniquely identify this Future instance. This value is consumed by the Future
+                infrastructure and is not passed to the target function.
             **kwargs: Additional keyword arguments to be passed to the function when executed.
+                All keyword arguments except 'future_id' are forwarded to the target function.
         """
         # Create a new available future
-        future = FutureUndefinedPending.auto()
+        future = FutureUndefinedPending.auto(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.thread = Thread(
-            target=lambda: future.apply(function=function, **kwargs),
+            target=lambda: future.apply(
+                function=function,
+                on_complete=on_complete,
+                **kwargs
+            ),
             daemon=True,
         )
         # Start the thread to execute the function asynchronously

{fred_oss-0.22.0 → fred_oss-0.24.0}/src/main/fred/future/result.py

@@ -17,8 +17,9 @@ from fred.future.settings import (
     FRD_FUTURE_DEFAULT_EXPIRATION,
     FRD_FUTURE_DEFAULT_TIMEOUT,
 )
-from fred.utils.dateops import datetime_utcnow
+from fred.future.callback.interface import CallbackInterface
 from fred.dao.service.catalog import ServiceCatalog
+from fred.utils.dateops import datetime_utcnow
 from fred.dao.comp.catalog import FredKeyVal
 from fred.monad.catalog import EitherMonad
 
@@ -162,7 +163,12 @@ class FutureUndefinedPending(FutureResult[A]):
             expire=FRD_FUTURE_DEFAULT_EXPIRATION
         )
 
-    def apply(self, function: Callable[..., A], **kwargs) -> 'FutureDefined[A]':
+    def apply(
+            self,
+            function: Callable[..., A],
+            on_complete: Optional[CallbackInterface] = None,
+            **kwargs
+        ) -> 'FutureDefined[A]':
         """Applies a function to the Future, transitioning it from pending to in-progress and finalizing as defined.
         This method executes the provided function with the given keyword arguments,
         transitioning the Future from a pending state to an in-progress state. It captures
@@ -179,7 +185,11 @@ class FutureUndefinedPending(FutureResult[A]):
             started_at=perf_counter(),
             function_name=function.__name__,
         )
-        return fip.exec(function=function, **kwargs)
+        return fip.exec(
+            function=function,
+            on_complete=on_complete,
+            **kwargs
+        )
 
 
 @dataclass(frozen=True, slots=False)
@@ -199,7 +209,13 @@ class FutureUndefinedInProgress(FutureResult[A]):
             expire=FRD_FUTURE_DEFAULT_EXPIRATION
         )
 
-    def exec(self, function: Callable[..., A], fail: bool = False, **kwargs) -> 'FutureDefined[A]':
+    def exec(
+            self,
+            function: Callable[..., A],
+            on_complete: Optional[CallbackInterface] = None,
+            fail: bool = False,
+            **kwargs,
+        ) -> 'FutureDefined[A]':
         """Executes the function associated with the Future, capturing its result or exception.
         This method runs the provided function with the given keyword arguments, capturing
         its output. If the function executes successfully, it wraps the result in a Right
@@ -231,11 +247,21 @@ class FutureUndefinedInProgress(FutureResult[A]):
             value = EitherMonad.Left.from_value(val=e)
             if fail:
                 raise e
-        return FutureDefined(
+        future_defined = FutureDefined(
             future_id=self.future_id,
             value=value,
             ok=ok,
         )
+        # We could do the following to have an "on_success" behaviour:
+        # value.map(lambda v: on_complete.run(v) if on_complete else None)
+        # But that would leave out the "on_failure" behaviour and we would probably need to
+        # add specific 'on_success' and 'on_failure' callbacks to mitigate that.
+        # Instead, we just do a generic 'on_complete' callback that gets executed
+        # wrapped on an Either monad so the user can handle success/failure as needed.
+        if on_complete:
+            logger.debug(f"Future[{self.future_id}] executing on_complete callback")
+            on_complete.run(value)
+        return future_defined
 
 
 @dataclass(frozen=True, slots=False)

fred_oss-0.24.0/src/main/fred/version

@@ -0,0 +1 @@
+0.24.0

{fred_oss-0.22.0 → fred_oss-0.24.0/src/main/fred_oss.egg-info}/PKG-INFO

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

{fred_oss-0.22.0 → fred_oss-0.24.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -27,6 +27,10 @@ src/main/fred/future/__init__.py
 src/main/fred/future/impl.py
 src/main/fred/future/result.py
 src/main/fred/future/settings.py
+src/main/fred/future/callback/__init__.py
+src/main/fred/future/callback/_function.py
+src/main/fred/future/callback/catalog.py
+src/main/fred/future/callback/interface.py
 src/main/fred/integrations/databricks/__init__.py
 src/main/fred/integrations/databricks/cli_ext.py
 src/main/fred/integrations/databricks/runtime.py

fred_oss-0.22.0/src/main/fred/version

@@ -1 +0,0 @@
-0.22.0