fred-oss 0.17.0__tar.gz → 0.19.0__tar.gz

{fred_oss-0.17.0/src/main/fred_oss.egg-info → fred_oss-0.19.0}/PKG-INFO

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

{fred_oss-0.17.0 → fred_oss-0.19.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):
@@ -12,8 +15,9 @@ class FredKeyVal(ComponentInterface):
     getting, and deleting key-value pairs. The actual implementation of these methods
     depends on the underlying service being used (e.g., Redis).
     """
+    key: str
     
-    def set(self, key: str, value: str, **kwargs) -> None:
+    def set(self, value: str, key: Optional[str] = None, **kwargs) -> None:
         """Sets a key-value pair in the store.
         The implementation of this method depends on the underlying service.
         For example, if the service is Redis, it uses the SET command to store the
@@ -26,16 +30,22 @@ class FredKeyVal(ComponentInterface):
         Raises:
             NotImplementedError: If the method is not implemented for the current service.
         """
+        key = key or self.key
         match self._cat:
             case ServiceCatalog.REDIS:
                 self._srv.client.set(key, value)
                 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}")
 
-    def get(self, key: str, fail: bool = False) -> Optional[str]:
+    def get(self, key: Optional[str] = None, fail: bool = False) -> Optional[str]:
         """Gets the value associated with a key from the store.
         The implementation of this method depends on the underlying service.
         For example, if the service is Redis, it uses the GET command to retrieve the
@@ -50,16 +60,20 @@ class FredKeyVal(ComponentInterface):
             KeyError: If the key is not found and fail is True.
             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: str) -> None:
+    def delete(self, key: Optional[str] = None) -> None:
         """Deletes a key-value pair from the store.
         The implementation of this method depends on the underlying service.
         For example, if the service is Redis, it uses the DEL command to remove the
@@ -69,8 +83,11 @@ class FredKeyVal(ComponentInterface):
         Raises:
             NotImplementedError: If the method is not implemented for the current service.
         """
+        key = key or self.key
         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.17.0 → fred_oss-0.19.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.19.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.17.0 → fred_oss-0.19.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.19.0/src/main/fred/version

@@ -0,0 +1 @@
+0.19.0

{fred_oss-0.17.0 → fred_oss-0.19.0/src/main/fred_oss.egg-info}/PKG-INFO

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

{fred_oss-0.17.0 → fred_oss-0.19.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

fred_oss-0.17.0/src/main/fred/version

@@ -1 +0,0 @@
-0.17.0