fred-oss 0.18.0__tar.gz → 0.20.0__tar.gz

{fred_oss-0.18.0/src/main/fred_oss.egg-info → fred_oss-0.20.0}/PKG-INFO

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

{fred_oss-0.18.0 → fred_oss-0.20.0}/src/main/fred/dao/comp/_keyval.py

@@ -1,9 +1,12 @@
 from dataclasses import dataclass
 from typing import Optional
 
+from fred.settings import logger_manager
 from fred.dao.service.catalog import ServiceCatalog
 from fred.dao.comp.interface import ComponentInterface
 
+logger = logger_manager.get_logger(name=__name__)
+
 
 @dataclass(frozen=True, slots=True)
 class FredKeyVal(ComponentInterface):
@@ -34,6 +37,11 @@ class FredKeyVal(ComponentInterface):
                 expire = kwargs.get("expire")
                 if expire and isinstance(expire, int):
                     self._srv.client.expire(key, expire)
+            case ServiceCatalog.STDLIB:
+                self._srv.client._memstore_keyval[key] = value
+                # TODO: Implement expiration logic
+                if "expire" in kwargs:
+                    logger.warning("Expiration not implemented for STDLIB service.")
             case _:
                 raise NotImplementedError(f"Set method not implemented for service {self._nme}")
 
@@ -53,14 +61,17 @@ class FredKeyVal(ComponentInterface):
             NotImplementedError: If the method is not implemented for the current service.
         """
         key = key or self.key
+        result = None
         match self._cat:
             case ServiceCatalog.REDIS:
                 result = self._srv.client.get(key)
-                if result is None and fail:
-                    raise KeyError(f"Key {key} not found.")
-                return result
+            case ServiceCatalog.STDLIB:
+                result = self._srv.client._memstore_keyval.get(key)
             case _:
                 raise NotImplementedError(f"Get method not implemented for service {self._nme}")
+        if fail and result is None:
+            raise KeyError(f"Key {key} not found.")
+        return result
 
     def delete(self, key: Optional[str] = None) -> None:
         """Deletes a key-value pair from the store.
@@ -76,5 +87,7 @@ class FredKeyVal(ComponentInterface):
         match self._cat:
             case ServiceCatalog.REDIS:
                 self._srv.client.delete(key)
+            case ServiceCatalog.STDLIB:
+                self._srv.client._memstore_keyval.pop(key, None)
             case _:
                 raise NotImplementedError(f"Delete method not implemented for service {self._nme}")

{fred_oss-0.18.0 → fred_oss-0.20.0}/src/main/fred/dao/comp/_queue.py

@@ -1,9 +1,12 @@
 from dataclasses import dataclass
 from typing import Optional
 
+from fred.settings import logger_manager
 from fred.dao.service.catalog import ServiceCatalog
 from fred.dao.comp.interface import ComponentInterface
 
+logger = logger_manager.get_logger(name=__name__)
+
 
 @dataclass(frozen=True, slots=True)
 class FredQueue(ComponentInterface):
@@ -29,6 +32,9 @@ class FredQueue(ComponentInterface):
         match self._cat:
             case ServiceCatalog.REDIS:
                 return self._srv.client.llen(self.name)
+            case ServiceCatalog.STDLIB:
+                q = self._srv.client._memstore_queue.get(self.name, None)
+                return q.qsize() if q else 0
             case _:
                 raise NotImplementedError(f"Size method not implemented for service {self._nme}")
 
@@ -43,6 +49,9 @@ class FredQueue(ComponentInterface):
         match self._cat:
             case ServiceCatalog.REDIS:
                 self._srv.client.delete(self.name)
+            case ServiceCatalog.STDLIB:
+                if (q := self._srv.client._memstore_queue.pop(self.name, None)):
+                    del q
             case _:
                 raise NotImplementedError(f"Clear method not implemented for service {self._nme}")
 
@@ -59,6 +68,11 @@ class FredQueue(ComponentInterface):
         match self._cat:
             case ServiceCatalog.REDIS:
                 self._srv.client.lpush(self.name, item)
+            case ServiceCatalog.STDLIB:
+                from queue import Queue
+                qs = self._srv.client._memstore_queue
+                q = qs[self.name] = qs.get(self.name, None) or Queue()
+                q.put(item)
             case _:
                 raise NotImplementedError(f"Add method not implemented for service {self._srv._nme}")
 
@@ -75,5 +89,14 @@ class FredQueue(ComponentInterface):
         match self._cat:
             case ServiceCatalog.REDIS:
                 return self._srv.client.rpop(self.name)
+            case ServiceCatalog.STDLIB:
+                from queue import Empty
+                if not (q := self._srv.client._memstore_queue.get(self.name, None)):
+                    return None
+                try:
+                    return q.get_nowait()
+                except Empty:
+                    logger.info(f"Queue '{self.name}' is empty.")
+                    return None
             case _:
                 raise NotImplementedError(f"Pop method not implemented for service {self._srv._nme}")

fred_oss-0.20.0/src/main/fred/dao/service/_stdlib.py

@@ -0,0 +1,54 @@
+from queue import Queue
+from dataclasses import dataclass
+from typing import Optional
+
+from fred.utils.runtime import RuntimeInfo
+from fred.dao.service.interface import ServiceConnectionPoolInterface, ServiceInterface
+
+
+class StdLibSingleton:
+    _instance: Optional["StdLib"] = None
+
+    @classmethod
+    def get_instance(cls, **kwargs) -> "StdLib":
+        if cls._instance is None:
+            cls._instance = StdLib.auto(**kwargs)
+        return cls._instance
+
+
+@dataclass(frozen=True, slots=True)
+class StdLib:
+    runtime_info: RuntimeInfo
+    _memstore_keyval: dict[str, str]
+    _memstore_queue: dict[str, Queue]
+
+    @classmethod
+    def auto(cls, **kwargs) -> "StdLib":
+        _memstore_keyval = kwargs.pop("memstore_keyval", {})
+        _memstore_queue = kwargs.pop("memstore_queue", {})
+        return cls(
+            runtime_info=RuntimeInfo.auto(**kwargs),
+            _memstore_keyval=_memstore_keyval,
+            _memstore_queue=_memstore_queue,
+        )
+
+
+class StdLibConnectionPool(ServiceConnectionPoolInterface[StdLibSingleton]):
+
+    @classmethod
+    def _create_pool(cls, **kwargs) -> StdLibSingleton:
+        return StdLibSingleton(**kwargs)
+
+
+class StdLibService(ServiceInterface[StdLib]):
+    instance: StdLib
+
+    @classmethod
+    def _create_instance(cls, **kwargs) -> StdLib:
+        pool = StdLibConnectionPool.get_or_create_pool(**kwargs)
+        return pool.get_instance(**kwargs)
+
+    @classmethod
+    def auto(cls, **kwargs) -> "StdLib":
+        cls.instance = cls._create_instance(**kwargs)
+        return cls(**kwargs)

{fred_oss-0.18.0 → fred_oss-0.20.0}/src/main/fred/dao/service/catalog.py

@@ -4,11 +4,13 @@ from typing import TypeVar, Optional
 
 from fred.dao.service.interface import ServiceInterface
 from fred.dao.service._redis import RedisService
+from fred.dao.service._stdlib import StdLibService
 
 T = TypeVar("T")
 
 
 class ServiceCatalog(enum.Enum):
+    STDLIB = StdLibService
     REDIS = RedisService
 
     @classmethod

fred_oss-0.20.0/src/main/fred/monad/__init__.py

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

fred_oss-0.20.0/src/main/fred/monad/_either.py

@@ -0,0 +1,93 @@
+from dataclasses import dataclass
+from functools import wraps
+from typing import (
+    Callable,
+    Generic,
+    Generator,
+    TypeVar,
+)
+
+from fred.settings import logger_manager
+from fred.monad.interface import MonadInterface
+
+logger = logger_manager.get_logger(__name__)
+
+A = TypeVar("A")
+B = TypeVar("B")
+
+
+@dataclass(frozen=True, slots=True)
+class EitherWrapper(Generic[A]):
+    function: Callable[..., A]
+
+    def __call__(self, *args, **kwargs) -> A:
+        return self.function(*args, **kwargs)
+
+    def either(self, *args, **kwargs)-> 'Either[A]':
+        try:
+            return Right[A].from_value(val=self.function(*args, **kwargs))
+        except Exception as e:
+            return Left(exception=e)
+
+
+class Either(MonadInterface[A]):
+
+    @classmethod
+    def comprehension(cls, generator: Generator):
+        try:
+            return Either.from_value(val=next(generator))
+        except Exception as e:
+            return Left(exception=e)
+
+    @classmethod
+    def decorator(cls, function: Callable):
+        return wraps(function, updated=())(EitherWrapper(function=function))
+
+    @classmethod
+    def from_value(cls, val: A) -> 'Either[A]':
+        if isinstance(val, Exception):
+            return Left(exception=val)
+        return Right(value=val)
+
+    def resolve(self) -> A:
+        match self:
+            case Right(value=value):
+                return value
+            case Left(exception=exception):
+                raise exception
+            case _:
+                raise TypeError("Unknown Either type")
+            
+    def __iter__(self) -> Generator[A, None, None]:
+        match self:
+            case Right(value=value):
+                yield from [value]
+            case Left(exception=exception):
+                logger.warning(f"Attempted to iterate over Left: {exception}")
+                yield from []
+            case _:
+                raise TypeError("Unknown Either type")
+
+
+@dataclass(frozen=True, slots=True)
+class Right(Either[A]):
+    value: A
+
+    def flat_map(self, function: Callable[[A], Either[B]]) -> Either[B]:
+        try:
+            return function(self.value)
+        except Exception as e:
+            logger.exception(f"Error in flat_map: {e}")
+            # Consider that a right that fails is a left
+            return Left(exception=e)
+
+
+@dataclass(frozen=True, slots=True)
+class Left(Either[A]):
+    exception: Exception
+
+    def flat_map(self, function: Callable[[A], Either[B]]) -> Either[B]:
+        return Left(exception=self.exception)  # Propagate exception
+    
+    def map(self, function: Callable[[A], B]) -> Either[B]:
+        return Left(exception=self.exception)  # Propagate exception

fred_oss-0.20.0/src/main/fred/monad/catalog.py

@@ -0,0 +1,11 @@
+import enum
+
+from fred.monad._either import Either, Left, Right
+
+
+class MonadCatalog(enum.Enum):
+    """Enum representing the different types of Monads."""
+    EITHER = type("Either", (Either,), {"Left": Left, "Right": Right})
+
+    def __call__(self, *args, **kwargs):
+        return self.value.from_value(*args, **kwargs)

fred_oss-0.20.0/src/main/fred/monad/interface.py

@@ -0,0 +1,22 @@
+from typing import (
+    Callable,
+    Generic,
+    TypeVar,
+)
+
+A = TypeVar("A")
+B = TypeVar("B")
+
+
+class MonadInterface(Generic[A]):
+    
+    @classmethod
+    def from_value(cls, val: A) -> 'MonadInterface[A]':
+        raise NotImplementedError
+    
+    def flat_map(self, function: Callable[[A], 'MonadInterface[B]']) -> 'MonadInterface[B]':
+        raise NotImplementedError
+
+    def map(self, function: Callable[[A], B]) -> 'MonadInterface[B]':
+        # Map can be implemented using flat_map to avoid code duplication and ensure consistency
+        return self.flat_map(function=lambda value: type(self).from_value(function(value)))

fred_oss-0.20.0/src/main/fred/version

@@ -0,0 +1 @@
+0.20.0

{fred_oss-0.18.0 → fred_oss-0.20.0/src/main/fred_oss.egg-info}/PKG-INFO

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

{fred_oss-0.18.0 → fred_oss-0.20.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/main/fred/dao/comp/catalog.py
 src/main/fred/dao/comp/interface.py
 src/main/fred/dao/service/__init__.py
 src/main/fred/dao/service/_redis.py
+src/main/fred/dao/service/_stdlib.py
 src/main/fred/dao/service/catalog.py
 src/main/fred/dao/service/interface.py
 src/main/fred/dao/service/utils.py
@@ -33,6 +34,10 @@ src/main/fred/integrations/databricks/wrappers/dbutils.py
 src/main/fred/integrations/runpod/__init__.py
 src/main/fred/integrations/runpod/cli_ext.py
 src/main/fred/integrations/runpod/helper.py
+src/main/fred/monad/__init__.py
+src/main/fred/monad/_either.py
+src/main/fred/monad/catalog.py
+src/main/fred/monad/interface.py
 src/main/fred/utils/__init__.py
 src/main/fred/utils/dateops.py
 src/main/fred/utils/runtime.py

fred_oss-0.18.0/src/main/fred/version

@@ -1 +0,0 @@
-0.18.0