fred-oss 0.49.0__tar.gz → 0.51.0__tar.gz

{fred_oss-0.49.0/src/main/fred_oss.egg-info → fred_oss-0.51.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.49.0
+Version: 0.51.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development
@@ -14,6 +14,7 @@ Requires-Dist: redis==6.4.0
 Requires-Dist: requests==2.32.5
 Requires-Dist: fastapi==0.116.2
 Requires-Dist: uvicorn[standard]==0.35.0
+Requires-Dist: minio==7.2.18
 Requires-Dist: pillow==11.3.0
 Dynamic: author
 Dynamic: author-email

{fred_oss-0.49.0 → fred_oss-0.51.0}/requirements.txt

@@ -7,6 +7,8 @@ redis==6.4.0
 requests==2.32.5
 fastapi==0.116.2
 uvicorn[standard]==0.35.0
+# Services
+minio==7.2.18
 # Fred Utils
 pillow==11.3.0
 # Databricks Runtime: 16.4 LTS (Python 3.12.3)

fred_oss-0.51.0/src/main/fred/dao/comp/_keyval.py

@@ -0,0 +1,176 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from fred.settings import logger_manager, get_environ_variable
+from fred.dao.service.catalog import ServiceCatalog
+from fred.dao.comp.interface import ComponentInterface
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+def _get_minio_elements_from_key(key: str, **kwargs) -> tuple[str, str]:
+    import os
+
+    fullpath = os.path.join(
+        kwargs.pop("bucket_name", get_environ_variable("MINIO_BUCKET")) or "",
+        key
+    )
+    bucket_name = os.path.dirname(fullpath)
+    object_name = os.path.basename(fullpath)
+    if not bucket_name:
+        raise ValueError(
+            "Bucket name must be specified either in kwargs, environment variable MINIO_BUCKET, "
+            "or implicitly as part of the key."
+        )
+    if not object_name:
+        raise ValueError("Object name cannot be empty.")
+    return bucket_name, object_name
+
+
+@dataclass(frozen=True, slots=True)
+class FredKeyVal(ComponentInterface):
+    """A simple key-value store implementation using a backend service.
+    This class provides methods to interact with a key-value store, such as setting,
+    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, 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
+        key-value pair.
+        Args:
+            key (str): The key to set.
+            value (str): The value to associate with the key.
+            **kwargs: Additional keyword arguments for setting the key-value pair,
+                      such as expiration time.
+        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 ServiceCatalog.MINIO:
+                # MinIO is not a key-value store, but we can simulate it:
+                # the key will be the object name, and the value will be the object content.
+                import io
+
+                bucket_name, object_name = _get_minio_elements_from_key(key, **kwargs)
+                # Ensure the bucket exists or create otherwise
+                if not self._srv.bucket_exists(bucket_name):
+                    logger.warning(f"Creating bucket since doesn't exists: {bucket_name}")
+                    self._srv.client.make_bucket(bucket_name)
+                if "expire" in kwargs:
+                    # TODO: Implement expiration logic
+                    logger.warning("Expiration not implemented for MINIO service.")
+                # Prepare the value as a byte stream
+                value_bytes = value.encode("utf-8")
+                value_stream = io.BytesIO(value_bytes)
+                value_stream.seek(0)  # Ensure the stream is at the beginning
+                # Put the object into the bucket
+                self._srv.client.put_object(
+                    bucket_name=bucket_name,
+                    object_name=object_name,
+                    data=value_stream,
+                    length=len(value_bytes),
+                )
+            case _:
+                raise NotImplementedError(f"Set method not implemented for service {self._nme}")
+
+    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
+        value associated with the key.
+        Args:
+            key (str): The key to retrieve.
+            fail (bool): If True, raises a KeyError if the key is not found. Defaults to False.
+        Returns:
+            Optional[str]: The value associated with the key, or None if the key is not found
+                           and fail is False.
+        Raises:
+            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)
+            case ServiceCatalog.STDLIB:
+                result = self._srv.client._memstore_keyval.get(key)
+            case ServiceCatalog.MINIO:
+                bucket_name, object_name = _get_minio_elements_from_key(key)
+                # Verify if the bucket exists
+                if not self._srv.bucket_exists(bucket_name):
+                    logger.warning(f"Bucket {bucket_name} does not exist.")
+                    if fail:
+                        raise KeyError(f"Bucket {bucket_name} does not exist.")
+                    return None
+                # Verify if the object exists
+                if not self._srv.object_exists(bucket_name, object_name):
+                    logger.warning(f"Object {object_name} in bucket {bucket_name} does not exist.")
+                    if fail:
+                        raise KeyError(f"Object {object_name} not found in bucket {bucket_name}.")
+                    return None
+                try:
+                    response = self._srv.client.get_object(bucket_name, object_name)
+                    result_bytes = response.read()
+                    result = result_bytes.decode("utf-8")
+                except Exception as e:
+                    logger.error(f"Error retrieving object {object_name} from bucket {bucket_name}: {e}")
+                    result = None
+                    if fail:
+                        raise KeyError(f"Object {object_name} not found in bucket {bucket_name}.")
+                finally:
+                    response.close()
+                    response.release_conn()
+            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.
+        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
+        key-value pair.
+        Args:
+            key (str): The key to delete.
+        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 ServiceCatalog.MINIO:
+                bucket_name, object_name = _get_minio_elements_from_key(key)
+                # Verify if the bucket exists
+                if not self._srv.bucket_exists(bucket_name):
+                    logger.warning(f"Bucket {bucket_name} does not exist.")
+                    return
+                # Verify if the object exists
+                if not self._srv.object_exists(bucket_name, object_name):
+                    logger.warning(f"Object {object_name} in bucket {bucket_name} does not exist.")
+                    return
+                try:
+                    self._srv.client.remove_object(bucket_name, object_name)
+                except Exception as e:
+                    logger.error(f"Error deleting object {object_name} from bucket {bucket_name}: {e}")
+            case _:
+                raise NotImplementedError(f"Delete method not implemented for service {self._nme}")

{fred_oss-0.49.0 → fred_oss-0.51.0}/src/main/fred/dao/comp/catalog.py

@@ -87,6 +87,19 @@ class CompCatalog(enum.Enum):
         """
         return self.value
 
+    def mount(self, srv_ref: Optional[SRV_REF_TYPE] = None, **kwargs) -> type[ComponentInterface]:
+        """Mounts the component to a specific service instance.
+        This method configures the component to use a service instance
+        identified by `srv_name` and any additional parameters passed via `kwargs`.
+        
+        Args:
+            srv_ref (Optional[SRV_REF_TYPE]): The service reference to mount the component to.
+            **kwargs: Additional keyword arguments to configure the service instance.
+        Returns:
+            type[ComponentInterface]: The component class mounted to the specified service.
+        """
+        return self.value.mount(srv_ref=srv_ref, **kwargs)
+
     def auto(self, srv_ref: Optional[SRV_REF_TYPE] = None, **kwargs) -> ComponentInterface:
         """Automatically creates an instance of the component, mounting it to a service.
         This method is a convenience wrapper that first mounts the component to a service

fred_oss-0.51.0/src/main/fred/dao/service/_minio.py

@@ -0,0 +1,122 @@
+from minio import Minio
+from urllib3 import PoolManager, Retry
+from urllib3.util import Timeout
+
+from fred.settings import get_environ_variable, logger_manager
+from fred.dao.service.utils import get_minio_from_payload
+from fred.dao.service.interface import ServiceInterface, ServiceConnectionPoolInterface
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+class MinioConnectionPool(ServiceConnectionPoolInterface[PoolManager]):
+
+    @classmethod
+    def _create_pool(cls, disable_cert: bool = False, **kwargs) -> PoolManager:
+        """Create a urllib3 PoolManager with the given configurations.
+
+        TODO: Consider using the inverse of 'require_cert' as the default to ensure we do have cert-check automatically.
+        For now, we keep it as is to avoid breaking changes.
+
+        Args:
+            require_cert (bool): Whether to require SSL certificate verification.
+            **kwargs: Additional keyword arguments to pass to the PoolManager constructor.
+        Returns:
+            PoolManager: A configured PoolManager instance.
+        """
+        num_pools = kwargs.pop("num_pools", 10)
+        maxsize = kwargs.pop("maxsize", 10)
+        # Default timeout of 5 minutes
+        timeout_seconds = kwargs.pop("timeout", 300)
+        timeout = Timeout(
+            connect=timeout_seconds,
+            read=timeout_seconds,
+        )
+        # Default retries of 5 with exponential backoff
+        retry = Retry(
+            total=kwargs.pop("retries", 5),
+            backoff_factor=kwargs.pop("backoff_factor", 0.25),
+            status_forcelist=[500, 502, 503, 504],
+        )
+        # Configure certificate requirements for SSL connections
+        cert_reqs = "CERT_NONE"
+        ca_certs = None
+        if not disable_cert:
+            import certifi
+            cert_reqs = "CERT_REQUIRED"
+            ca_certs = get_environ_variable("SSL_CERT_FILE") or certifi.where()
+        # Finally, create and return the PoolManager instance
+        return PoolManager(
+            num_pools=num_pools,
+            maxsize=maxsize,
+            timeout=timeout,
+            retries=retry,
+            cert_reqs=cert_reqs,
+            ca_certs=ca_certs,
+            **kwargs
+        )
+
+
+class MinioService(ServiceInterface[Minio]):
+    instance: Minio
+    metadata: dict = {}
+
+    @classmethod
+    def _create_instance(cls, disable_cert: bool = False, **kwargs) -> Minio:
+        pool_configs = kwargs.pop("pool_configs", {})
+        minio_configs = get_minio_from_payload(kwargs)
+        if "http_client" not in minio_configs:
+            logger.warning("Creating a new HTTP client for MinIO with connection pooling.")
+            minio_configs["http_client"] = MinioConnectionPool.get_or_create_pool(
+                disable_cert=disable_cert,
+                **pool_configs
+            )
+        cls.metadata["minio_endpoint"] = minio_configs.get("endpoint")
+        return Minio(cert_check=not disable_cert, **minio_configs)
+
+    @classmethod
+    def auto(cls, disable_cert: bool = False, **kwargs) -> "MinioService":
+        cls.instance = cls._create_instance(disable_cert=disable_cert, **kwargs)
+        return cls(**kwargs)
+
+    def buckets(self) -> list[str]:
+        """List all buckets in the MinIO instance."""
+        return [
+            bucket.name
+            for bucket in self.client.list_buckets()
+        ]
+
+    def objects(self, bucket_name: str, prefix: str = "", shallow: bool = False) -> list[str]:
+        """List all objects in a specific bucket in the MinIO instance."""
+        return [
+            obj.object_name
+            for obj in self.client.list_objects(bucket_name, prefix=prefix, recursive=not shallow)
+        ]
+
+    def bucket_exists(self, bucket_name: str) -> bool:
+        """Check if a bucket exists in the MinIO instance."""
+        return self.client.bucket_exists(bucket_name)
+    
+    def object_info(self, bucket_name: str, object_name: str) -> dict:
+        """Get metadata of an object in a specific bucket in the MinIO instance."""
+        stat = self.client.stat_object(bucket_name, object_name)
+        return {
+            "bucket_name": bucket_name,
+            "object_name": object_name,
+            "size": stat.size,
+            "last_modified": stat.last_modified,
+            "etag": stat.etag,
+            "content_type": stat.content_type,
+            "metadata": stat.metadata,
+        }
+
+    def object_exists(self, bucket_name: str, object_name: str) -> bool:
+        """Check if an object exists in a specific bucket in the MinIO instance."""
+        from minio.error import S3Error
+
+        try:
+            self.client.stat_object(bucket_name, object_name)
+            return True
+        except S3Error:
+            logger.debug(f"Object {object_name} in bucket {bucket_name} does not exist.")
+            return False

{fred_oss-0.49.0 → fred_oss-0.51.0}/src/main/fred/dao/service/catalog.py

@@ -3,6 +3,7 @@ from functools import lru_cache
 from typing import TypeVar, Optional
 
 from fred.dao.service.interface import ServiceInterface
+from fred.dao.service._minio import MinioService
 from fred.dao.service._redis import RedisService
 from fred.dao.service._stdlib import StdLibService
 
@@ -12,6 +13,7 @@ T = TypeVar("T")
 class ServiceCatalog(enum.Enum):
     STDLIB = StdLibService
     REDIS = RedisService
+    MINIO = MinioService
 
     @classmethod
     def from_classname(cls, classname: str) -> "ServiceCatalog":

{fred_oss-0.49.0 → fred_oss-0.51.0}/src/main/fred/dao/service/interface.py

@@ -29,6 +29,7 @@ class ServiceConnectionPoolInterface(Generic[T]):
 
 class ServiceInterface(Generic[T]):
     instance: T
+    metadata: dict
 
     def __init__(self, **kwargs):
         self.config = kwargs

fred_oss-0.51.0/src/main/fred/dao/service/utils.py

@@ -0,0 +1,76 @@
+from fred.settings import get_environ_variable
+
+
+def get_redis_configs_from_payload(
+        payload: dict,
+        keep: bool = False,
+    ) -> dict:
+    """Extract Redis configuration from the given payload dictionary.
+    This function looks for common Redis configuration keys in the payload
+    dictionary. If a key is not found, it falls back to environment variables.
+    Args:
+        payload (dict): The dictionary from which to extract Redis configuration.
+        keep (bool): If True, the original keys are retained in the payload. If False, they are removed.
+    Returns:
+        dict: A dictionary containing Redis configuration parameters.
+    """
+    host = port = password = db = None
+    for host_key in ["host", "redis_host"]:
+        if (host := payload.get(host_key) if keep else payload.pop(host_key, None)):
+            break
+    for port_key in ["port", "redis_port"]:
+        if (port := payload.get(port_key) if keep else payload.pop(port_key, None)):
+            break
+    for password_key in ["password", "redis_password"]:
+        if (password := payload.get(password_key) if keep else payload.pop(password_key, None)):
+            break
+    for db_key in ["db", "redis_db"]:
+        if (db := payload.get(db_key) if keep else payload.pop(db_key, None)):
+            break
+    return {
+        "host": host or get_environ_variable(name="REDIS_HOST", default=None) or "localhost",
+        "port": int(port or get_environ_variable(name="REDIS_PORT", default=None) or 6379),
+        "password": password or get_environ_variable(name="REDIS_PASSWORD", default=None),
+        "db": int(db or get_environ_variable(name="REDIS_DB", default=None) or 0),
+        "decode_responses": True,
+        **(payload.get("redis_configs", {}) if keep else payload.pop("redis_configs", {})),
+    }
+
+
+def get_minio_from_payload(
+        payload: dict,
+        keep: bool = False,
+):
+    """Extract MinIO configuration from the given payload dictionary.
+    This function looks for common MinIO configuration keys in the payload
+    dictionary. If a key is not found, it falls back to environment variables.
+    Args:
+        payload (dict): The dictionary from which to extract MinIO configuration.
+        keep (bool): If True, the original keys are retained in the payload. If False, they are removed.
+    Returns:
+        dict: A dictionary containing MinIO configuration parameters.
+    """
+    endpoint = access_key = secret_key = region = secure = None
+    for endpoint_key in ["endpoint", "minio_endpoint"]:
+        if (endpoint := payload.get(endpoint_key) if keep else payload.pop(endpoint_key, None)):
+            break
+    for access_key_key in ["access_key", "minio_access_key"]:
+        if (access_key := payload.get(access_key_key) if keep else payload.pop(access_key_key, None)):
+            break
+    for secret_key_key in ["secret_key", "minio_secret_key"]:
+        if (secret_key := payload.get(secret_key_key) if keep else payload.pop(secret_key_key, None)):
+            break
+    for secure_key in ["secure", "minio_secure"]:
+        if (secure := payload.get(secure_key) if keep else payload.pop(secure_key, None)):
+            break
+    for region_key in ["region", "minio_region"]:
+        if (region := payload.get(region_key) if keep else payload.pop(region_key, None)):
+            break
+    return {
+        "endpoint": endpoint or get_environ_variable(name="MINIO_ENDPOINT", default=None) or "localhost:9000",
+        "access_key": access_key or get_environ_variable(name="MINIO_ACCESS_KEY", default=None) or "minioadmin",
+        "secret_key": secret_key or get_environ_variable(name="MINIO_SECRET_KEY", default=None) or "minioadmin",
+        "secure": bool(secure or get_environ_variable(name="MINIO_SECURE", default=None) or True),  # Default to True
+        "region": region or get_environ_variable(name="MINIO_REGION", default=None) or "us-east-1",
+        **(payload.get("minio_configs", {}) if keep else payload.pop("minio_configs", {})),
+    }

fred_oss-0.51.0/src/main/fred/utils/imout/_minio.py

@@ -0,0 +1,33 @@
+import posixpath
+
+from fred.utils.imout.interface import ImageOutputInterface
+
+
+class OutputMinio(ImageOutputInterface):
+    """MinIO image output handling."""
+
+    @classmethod
+    def auto(cls, **kwargs) -> "OutputMinio":
+        from fred.dao.service.catalog import ServiceCatalog
+        from fred.dao.comp.catalog import CompCatalog
+
+        minio = ServiceCatalog.MINIO.auto(**kwargs)
+        if "minio_endpoint" in minio.metadata:
+            cls.metadata["minio_endpoint"] = minio.metadata["minio_endpoint"]
+        cls.client = CompCatalog.KEYVAL.mount(minio)
+        return cls(**kwargs)
+
+    def out(self, bucket: str, filename: str, presigned: bool = False, **kwargs) -> str:
+        from fred.utils.imops import image_to_b64
+
+        image_key = posixpath.join(bucket, filename)
+        image_string = image_to_b64(self.image)
+        self.client(key=image_key).set(image_string,  **kwargs)
+        if not presigned:
+            return posixpath.join(
+                self.metadata.get("minio_endpoint", ""),
+                image_key,
+            )
+        # TODO: Implement the generation of a pre-signed URL
+        # https://github.com/minio/minio-py/blob/master/docs/API.md#get_presigned_url
+        raise NotImplementedError("Presigned URL generation is not yet implemented.")

{fred_oss-0.49.0 → fred_oss-0.51.0}/src/main/fred/utils/imout/catalog.py

@@ -5,12 +5,14 @@ from PIL.Image import Image
 from fred.utils.imout.interface import ImageOutputInterface
 from fred.utils.imout._filesystem import OutputFilesystem
 from fred.utils.imout._string import OutputString
+from fred.utils.imout._minio import OutputMinio
 
 
 class ImageOutputCatalog(enum.Enum):
     B64 = OutputString
     STRING = OutputString
-    FILESYSTEM = OutputFilesystem 
+    FILESYSTEM = OutputFilesystem
+    MINIO = OutputMinio
 
     def __call__(self, image: Image, **kwargs) -> ImageOutputInterface:
         if getattr(self.value, "auto", None):

{fred_oss-0.49.0 → fred_oss-0.51.0}/src/main/fred/utils/imout/interface.py

@@ -8,16 +8,16 @@ class ImageOutputBackendInterface:
     metadata: dict = {}
     client: Optional[Any] = None  # Placeholder for clients like MinIO, S3, etc.
 
-    @classmethod
-    def set_shared_client(cls, client: Any) -> None:
-        cls.client = client
-
 
 @dataclass(frozen=True, slots=True)
 class ImageOutputInterface(ImageOutputBackendInterface):
     """Interface for image output handling."""
     image: Image
 
+    @classmethod
+    def auto(cls, **kwargs) -> 'ImageOutputInterface':
+        return cls(**kwargs)
+
     @classmethod
     def from_path(cls, path: str) -> "ImageOutputInterface":
         from fred.utils.imops import get_image_from_path

fred_oss-0.51.0/src/main/fred/version

@@ -0,0 +1 @@
+0.51.0

{fred_oss-0.49.0 → fred_oss-0.51.0/src/main/fred_oss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.49.0
+Version: 0.51.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development
@@ -14,6 +14,7 @@ Requires-Dist: redis==6.4.0
 Requires-Dist: requests==2.32.5
 Requires-Dist: fastapi==0.116.2
 Requires-Dist: uvicorn[standard]==0.35.0
+Requires-Dist: minio==7.2.18
 Requires-Dist: pillow==11.3.0
 Dynamic: author
 Dynamic: author-email

{fred_oss-0.49.0 → fred_oss-0.51.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/main/fred/dao/comp/_queue.py
 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/_minio.py
 src/main/fred/dao/service/_redis.py
 src/main/fred/dao/service/_stdlib.py
 src/main/fred/dao/service/catalog.py
@@ -54,6 +55,7 @@ src/main/fred/utils/imops.py
 src/main/fred/utils/runtime.py
 src/main/fred/utils/imout/__init__.py
 src/main/fred/utils/imout/_filesystem.py
+src/main/fred/utils/imout/_minio.py
 src/main/fred/utils/imout/_string.py
 src/main/fred/utils/imout/catalog.py
 src/main/fred/utils/imout/interface.py

{fred_oss-0.49.0 → fred_oss-0.51.0}/src/main/fred_oss.egg-info/requires.txt

@@ -4,4 +4,5 @@ redis==6.4.0
 requests==2.32.5
 fastapi==0.116.2
 uvicorn[standard]==0.35.0
+minio==7.2.18
 pillow==11.3.0

fred_oss-0.49.0/src/main/fred/dao/comp/_keyval.py

@@ -1,93 +0,0 @@
-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):
-    """A simple key-value store implementation using a backend service.
-    This class provides methods to interact with a key-value store, such as setting,
-    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, 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
-        key-value pair.
-        Args:
-            key (str): The key to set.
-            value (str): The value to associate with the key.
-            **kwargs: Additional keyword arguments for setting the key-value pair,
-                      such as expiration time.
-        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: 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
-        value associated with the key.
-        Args:
-            key (str): The key to retrieve.
-            fail (bool): If True, raises a KeyError if the key is not found. Defaults to False.
-        Returns:
-            Optional[str]: The value associated with the key, or None if the key is not found
-                           and fail is False.
-        Raises:
-            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)
-            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.
-        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
-        key-value pair.
-        Args:
-            key (str): The key to delete.
-        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.49.0/src/main/fred/dao/service/utils.py

@@ -1,37 +0,0 @@
-from fred.settings import get_environ_variable
-
-
-def get_redis_configs_from_payload(
-        payload: dict,
-        keep: bool = False,
-    ) -> dict:
-    """Extract Redis configuration from the given payload dictionary.
-    This function looks for common Redis configuration keys in the payload
-    dictionary. If a key is not found, it falls back to environment variables.
-    Args:
-        payload (dict): The dictionary from which to extract Redis configuration.
-        keep (bool): If True, the original keys are retained in the payload. If False, they are removed.
-    Returns:
-        dict: A dictionary containing Redis configuration parameters.
-    """
-    host = port = password = db = None
-    for host_key in ["host", "redis_host"]:
-        if (host := payload.get(host_key) if keep else payload.pop(host_key, None)):
-            break
-    for port_key in ["port", "redis_port"]:
-        if (port := payload.get(port_key) if keep else payload.pop(port_key, None)):
-            break
-    for password_key in ["password", "redis_password"]:
-        if (password := payload.get(password_key) if keep else payload.pop(password_key, None)):
-            break
-    for db_key in ["db", "redis_db"]:
-        if (db := payload.get(db_key) if keep else payload.pop(db_key, None)):
-            break
-    return {
-        "host": host or get_environ_variable(name="REDIS_HOST", default=None) or "localhost",
-        "port": int(port or get_environ_variable(name="REDIS_PORT", default=None) or 6379),
-        "password": password or get_environ_variable(name="REDIS_PASSWORD", default=None),
-        "db": int(db or get_environ_variable(name="REDIS_DB", default=None) or 0),
-        "decode_responses": True,
-        **(payload.get("redis_configs", {}) if keep else payload.pop("redis_configs", {})),
-    }

fred_oss-0.49.0/src/main/fred/version

@@ -1 +0,0 @@
-0.49.0