fred-oss 0.56.0__tar.gz → 0.58.0__tar.gz

{fred_oss-0.56.0/src/main/fred_oss.egg-info → fred_oss-0.58.0}/PKG-INFO

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

{fred_oss-0.56.0 → fred_oss-0.58.0}/src/main/fred/dao/comp/_keyval.py

@@ -136,7 +136,7 @@ class FredKeyVal(ComponentInterface):
             case _:
                 raise NotImplementedError(f"Set method not implemented for service {self._nme}")
 
-    def get(self, key: Optional[str] = None, fail: bool = False) -> Optional[str]:
+    def get(self, key: Optional[str] = None, fail: bool = False, **kwargs) -> 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
@@ -173,21 +173,32 @@ class FredKeyVal(ComponentInterface):
                         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")
+                    if kwargs.pop("presigned_url", False):
+                        result = self._srv.object_presigned_url(bucket_name, object_name, **kwargs)
+                    else:
+                        response = self._srv.client.get_object(bucket_name, object_name)
+                        result_bytes = response.read()
+                        try:
+                            # This should work for most cases where original text data was stored (e.g., JSON, YAML, CSVs, etc.)
+                            result = result_bytes.decode("utf-8")
+                        except UnicodeDecodeError:
+                            import base64
+                            # This should work for binary data (e.g., images, PDFs, etc.)
+                            result = base64.b64encode(result_bytes).decode("ascii")
+                        finally:
+                            response.close()
+                            response.release_conn()
                 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.")
+        if kwargs:
+            logger.warning(f"Additional kwargs ignored: {kwargs}")
         return result
 
     def delete(self, key: Optional[str] = None) -> None:

{fred_oss-0.56.0 → fred_oss-0.58.0}/src/main/fred/dao/service/_minio/service.py

@@ -1,3 +1,5 @@
+import datetime as dt
+
 from minio import Minio
 
 from fred.settings import logger_manager
@@ -62,6 +64,15 @@ class MinioService(ServiceInterface[Minio]):
             "metadata": stat.metadata,
         }
 
+    def object_presigned_url(self, bucket_name: str, object_name: str, expiration_hours: int = 6, **kwargs) -> str:
+        """Generate a presigned URL for an object in a specific bucket in the MinIO instance."""
+        return self.client.presigned_get_object(
+            bucket_name=bucket_name,
+            object_name=object_name,
+            expires=dt.timedelta(hours=expiration_hours),
+            **kwargs,
+        )
+
     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

{fred_oss-0.56.0 → fred_oss-0.58.0}/src/main/fred/rest/router/endpoint.py

@@ -62,7 +62,7 @@ class RouterEndpointAnnotation(RouterEndpoint):
         config = RouterEndpointConfig.auto(**kwargs)
         return lambda function: cls(function=function, configs=config)
 
-    def __get__(self, other, other_type):
+    def __get__(self, other_instance, other_class) -> RouterEndpoint:
         # Create a partial function that binds the instance (other) to the method.
         # This method was originally implemented using the following approaches:
         # - function = functools.partial(self.function, other)
@@ -87,7 +87,10 @@ class RouterEndpointAnnotation(RouterEndpoint):
                     params.update(await request.json())
             except Exception:
                 pass
-            return self.function(other, **params)
+            # Since the annotation is usually applied to methods within a class,
+            # in most cases the 'other_instance' will be 'None'; therefore using 'other_class'
+            # should allow accessing the shared-class level state (e.g., runner_backend).
+            return self.function(other_class, **params)
         return RouterEndpoint(
             function=closure,
             configs=self.configs

fred_oss-0.58.0/src/main/fred/version

@@ -0,0 +1 @@
+0.58.0

fred_oss-0.58.0/src/main/fred/worker/runner/rest/router/_base.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+from fred.rest.router.interface import RouterInterfaceMixin
+from fred.rest.router.endpoint import RouterEndpointAnnotation
+
+@dataclass(frozen=True, slots=True)
+class RouterBaseMixin(RouterInterfaceMixin):
+    
+    @RouterEndpointAnnotation.set(
+        path="/",
+        methods=["GET"],
+        summary="Base endpoint",
+        description="A simple base endpoint to check service availability."
+    )
+    def base(self, include_telemetry: bool = False, **kwargs) -> dict:
+        if include_telemetry:
+            from fred.utils.runtime import RuntimeProfilingSnapshot
+            kwargs["telemetry"] = RuntimeProfilingSnapshot.auto().to_dict()
+        return {
+            "ok": True,
+            **kwargs
+        }

{fred_oss-0.56.0/src/main/fred/worker/runner/rest/routers → fred_oss-0.58.0/src/main/fred/worker/runner/rest/router}/_runner.py

@@ -1,17 +1,24 @@
-from dataclasses import dataclass
 from typing import Optional
 
 from fred.future import Future
 from fred.settings import logger_manager
 from fred.utils.dateops import datetime_utcnow
-from fred.worker.runner.rest.routers.interface import RouterInterface
+from fred.rest.router.interface import RouterInterfaceMixin
+from fred.rest.router.endpoint import RouterEndpointAnnotation
 
 logger = logger_manager.get_logger(name=__name__)
 
 
-class RunnerRouterMethods:
+class RunnerRouterMixin(RouterInterfaceMixin):
 
-    def handler_exists(self, classname: str, classpath: str) -> dict:
+    @RouterEndpointAnnotation.set(
+        path="/handler_exists",
+        methods=["GET"],
+        tags=["Runner"],
+        summary="Check if a handler class exists and is a RunnerHandler.",
+        response_description="Details about the handler class.",
+    )
+    def handler_exists(self, classname: str, classpath: str, **kwargs) -> dict:
         from fred.worker.runner.handler import RunnerHandler
         from fred.worker.interface import HandlerInterface
 
@@ -35,8 +42,15 @@ class RunnerRouterMethods:
             result_payload["metadata"]["error"] = str(e)
             return result_payload
 
-    def qlen(self, queue_slug: str) -> dict:
 
+    @RouterEndpointAnnotation.set(
+        path="/qlen/{queue_slug}",
+        methods=["GET"],
+        tags=["Runner"],
+        summary="Get the length of the request and response queues for a given queue slug.",
+        response_description="The lengths of the request and response queues.",
+    )
+    def qlen(self, queue_slug: str, **kwargs) -> dict:
         snapshot_at = datetime_utcnow().isoformat()
         req_queue = self.runner_backend.queue(f"req:{queue_slug}")
         res_queue = self.runner_backend.queue(f"res:{queue_slug}")
@@ -49,34 +63,48 @@ class RunnerRouterMethods:
             "res": res_queue.size(),
         }
 
-    def runner_start(self, payload: dict) -> dict:
+    @RouterEndpointAnnotation.set(
+        path="/start",
+        methods=["POST"],
+        tags=["Runner"],
+        summary="Start a runner using the specified plugin.",
+        response_description="The ID of the started runner.",
+    )
+    def runner_start(self, **kwargs) -> dict:
         from fred.worker.runner.model.catalog import RunnerModelCatalog
         from fred.worker.runner.plugins.catalog import PluginCatalog
         # Determine which plugin to use; default to LOCAL if not specified
-        plugin_name: str = payload.pop("plugin", "LOCAL")
-        wait_for_exec: bool = payload.pop("wait_for_exec", False)
+        plugin_name: str = kwargs.pop("plugin", "LOCAL")
+        wait_for_exec: bool = kwargs.pop("wait_for_exec", False)
         # Create the RunnerSpec from the provided payload
         # TODO: Instead on depending on parsing a dict... Can we implement a base-model to facilitate fast-api validation?
-        runner_spec = RunnerModelCatalog.RUNNER_SPEC.value.from_payload(payload=payload)
+        runner_spec = RunnerModelCatalog.RUNNER_SPEC.value.from_payload(payload=kwargs)
         # Instantiate the plugin and execute the runner
         plugin = PluginCatalog[plugin_name.upper()]()
-        output = plugin.execute(runner_spec, wait_for_exec=wait_for_exec, **payload)
+        output = plugin.execute(runner_spec, wait_for_exec=wait_for_exec, **kwargs)
         return {
             "runner_id": output.runner_id,
             "future_id": output.future_exec.future_id,
             "queue_slug": runner_spec.queue_slug,
         }
-    
-    def runner_execute(self, payload: dict) -> dict:
+
+    @RouterEndpointAnnotation.set(
+        path="/execute",
+        methods=["POST"],
+        tags=["Runner"],
+        summary="Execute a task by dispatching a request to the specified queue.",
+        response_description="Details about the dispatched request.",
+    )
+    def runner_execute(self, **kwargs) -> dict:
         from fred.worker.runner.model.catalog import RunnerModelCatalog
 
-        request_id = payload.pop("request_id", None)
-        queue_slug = payload.pop("queue_slug", None) or (
+        request_id = kwargs.pop("request_id", None)
+        queue_slug = kwargs.pop("queue_slug", None) or (
             logger.error("No 'queue_slug' value provided; defaulting to 'demo'.")
             or "demo"
         )
 
-        item = RunnerModelCatalog.ITEM.value.uuid(payload=payload, uuid_hash=False)
+        item = RunnerModelCatalog.ITEM.value.uuid(payload=kwargs, uuid_hash=False)
         request = item.as_request(use_hash=False, request_id=request_id)
         request.dispatch(
             request_queue=self.runner_backend.queue(f"req:{queue_slug}")
@@ -88,7 +116,14 @@ class RunnerRouterMethods:
             "dispatched_at": datetime_utcnow().isoformat(),
         }
 
-    def runner_output(self, request_id: str, nonblocking: bool = False, timeout: Optional[float] = None) -> dict:
+    @RouterEndpointAnnotation.set(
+        path="/output/{request_id}",
+        methods=["GET"],
+        tags=["Runner"],
+        summary="Fetch the output of a previously dispatched request.",
+        response_description="The output of the request.",
+    )
+    def runner_output(self, request_id: str, nonblocking: bool = False, timeout: Optional[float] = None, **kwargs) -> dict:
 
         output_requested_at = datetime_utcnow().isoformat()
         # Subscribe to the future result using the request_id
@@ -102,49 +137,3 @@ class RunnerRouterMethods:
             "output_delivered_at": datetime_utcnow().isoformat(),
             "output": future.wait_and_resolve(timeout=timeout),
         }
-
-
-@dataclass(frozen=True, slots=False)
-class RunnerRouter(RouterInterface.with_backend(), RunnerRouterMethods):
-
-    def __post_init__(self):
-        self.router.add_api_route(
-            "/handler_exists",
-            self.handler_exists,
-            methods=["GET"],
-            tags=["Runner"],
-            summary="Check if a handler class exists and is a RunnerHandler.",
-            response_description="Details about the handler class.",
-        )
-        self.router.add_api_route(
-            "/qlen/{queue_slug}",
-            self.qlen,
-            methods=["GET"],
-            tags=["Runner"],
-            summary="Get the length of the request and response queues for a given queue slug.",
-            response_description="The lengths of the request and response queues.",
-        )
-        self.router.add_api_route(
-            "/start",
-            self.runner_start,
-            methods=["POST"],
-            tags=["Runner"],
-            summary="Start a runner using the specified plugin.",
-            response_description="The ID of the started runner.",
-        )
-        self.router.add_api_route(
-            "/execute",
-            self.runner_execute,
-            methods=["POST"],
-            tags=["Runner"],
-            summary="Execute a task by dispatching a request to the specified queue.",
-            response_description="Details about the dispatched request.",
-        )
-        self.router.add_api_route(
-            "/output/{request_id}",
-            self.runner_output,
-            methods=["GET"],
-            tags=["Runner"],
-            summary="Fetch the output of a previously dispatched request.",
-            response_description="The output of the request.",
-        )

fred_oss-0.58.0/src/main/fred/worker/runner/rest/router/catalog.py

@@ -0,0 +1,11 @@
+import enum
+
+from fred.rest.router.config import RouterConfig
+from fred.rest.router.catalog.interface import RouterCatalogInterface
+from fred.worker.runner.rest.router._runner import RunnerRouterMixin
+from fred.worker.runner.rest.router._base import RouterBaseMixin
+
+
+class RouterCatalog(RouterCatalogInterface, enum.Enum):
+    BASE = RouterConfig.auto(prefix="")(apply=RouterBaseMixin)
+    RUNNER = RouterConfig.auto(prefix="/runner", tags=["Runner"])(apply=RunnerRouterMixin)

{fred_oss-0.56.0 → fred_oss-0.58.0/src/main/fred_oss.egg-info}/PKG-INFO

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

{fred_oss-0.56.0 → fred_oss-0.58.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -109,14 +109,10 @@ src/main/fred/worker/runner/plugins/_runpod.py
 src/main/fred/worker/runner/plugins/catalog.py
 src/main/fred/worker/runner/plugins/interface.py
 src/main/fred/worker/runner/rest/__init__.py
-src/main/fred/worker/runner/rest/auth.py
-src/main/fred/worker/runner/rest/cli_ext.py
-src/main/fred/worker/runner/rest/server.py
-src/main/fred/worker/runner/rest/settings.py
-src/main/fred/worker/runner/rest/routers/__init__.py
-src/main/fred/worker/runner/rest/routers/_runner.py
-src/main/fred/worker/runner/rest/routers/catalog.py
-src/main/fred/worker/runner/rest/routers/interface.py
+src/main/fred/worker/runner/rest/router/__init__.py
+src/main/fred/worker/runner/rest/router/_base.py
+src/main/fred/worker/runner/rest/router/_runner.py
+src/main/fred/worker/runner/rest/router/catalog.py
 src/main/fred_oss.egg-info/PKG-INFO
 src/main/fred_oss.egg-info/SOURCES.txt
 src/main/fred_oss.egg-info/dependency_links.txt

fred_oss-0.56.0/src/main/fred/version

@@ -1 +0,0 @@
-0.56.0

fred_oss-0.56.0/src/main/fred/worker/runner/rest/auth.py

@@ -1,22 +0,0 @@
-from fastapi import Security, HTTPException, status
-from fastapi.security import APIKeyHeader
-
-from fred.worker.runner.rest.settings import FRD_RESTAPI_TOKEN
-
-async def verify_key(
-        api_key_header: str = Security(
-            APIKeyHeader(
-                name="X-API-Key",
-                auto_error=False
-            )
-        ),
-):
-    """
-    Verify the provided API key against the expected token.
-    Raises an HTTPException if the key is invalid or missing.
-    """
-    if api_key_header != FRD_RESTAPI_TOKEN:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid or missing API Key",
-        )

fred_oss-0.56.0/src/main/fred/worker/runner/rest/cli_ext.py

@@ -1,32 +0,0 @@
-from typing import Optional
-
-from fred.cli.interface import IntegrationExtCLI
-from fred.settings import logger_manager
-
-
-logger = logger_manager.get_logger(name=__name__)
-
-
-class RunnerServerExt(IntegrationExtCLI):
-
-    def start(
-            self,
-            include_routers: Optional[list[str]] = None,
-            exclude_routers: Optional[list[str]] = None,
-            fast_api_configs: Optional[dict] = None,
-            server_configs: Optional[dict] = None,
-        ):
-        from fred.worker.runner.rest.server import RunnerServer
-
-        include_routers = include_routers or []
-        exclude_routers = exclude_routers or []
-        fast_api_configs = fast_api_configs or {}
-        server_configs = server_configs or {}
-
-        logger.info("Starting REST server...")
-        server = RunnerServer.auto(
-            include_routers=include_routers,
-            exclude_routers=exclude_routers,
-            **fast_api_configs,
-        )
-        server.start(**server_configs)

fred_oss-0.56.0/src/main/fred/worker/runner/rest/routers/catalog.py

@@ -1,18 +0,0 @@
-import enum
-
-from fred.worker.runner.rest.routers.interface import RouterInterface
-from fred.worker.runner.rest.routers._runner import RunnerRouter
-
-
-class RouterCatalog(enum.Enum):
-    EXAMPLE = RouterInterface.auto()  # Default example router directly from the base interface
-    RUNNER = RunnerRouter.auto(
-        prefix="/runner",
-        tags=["Runner"],
-    )
-
-    def get_router_instance(self) -> RouterInterface:
-        return self.value.router
-
-    def get_router_configs(self) -> dict:
-        return self.value.router_configs

fred_oss-0.56.0/src/main/fred/worker/runner/rest/routers/interface.py

@@ -1,59 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from fred.worker.runner.backend import RunnerBackend
-from fred.worker.runner.settings import FRD_RUNNER_BACKEND
-
-from fastapi import APIRouter
-
-
-class RouterInterfaceBackendMixin:
-    """Base class for router interfaces that require a backend service."""
-    runner_backend: RunnerBackend
-
-    @classmethod
-    def with_backend(cls, service_name: Optional[str] = None, **kwargs) -> type["RouterInterfaceBackendMixin"]:
-        # Avoid re-initializing if already set
-        if getattr(cls, "runner_backend", None):
-            return cls
-        # Initialize the backend once and assign to the class attribute
-        cls.runner_backend = RunnerBackend.auto(
-            service_name=service_name or FRD_RUNNER_BACKEND,
-            **kwargs,
-        )
-        return cls
-
-
-@dataclass(frozen=True, slots=False)
-class RouterInterface(RouterInterfaceBackendMixin):
-    router: APIRouter
-    router_configs: dict
-
-    @classmethod
-    def auto(
-        cls,
-        router: Optional[APIRouter] = None,
-        **kwargs,
-    ) -> "RouterInterface":
-        return cls(
-            router=router or APIRouter(),
-            router_configs=kwargs,
-        )
-
-    def __post_init__(self):
-        self.router.add_api_route(
-            "/ping",
-            self.ping,
-            methods=["GET"],
-            tags=["Health"],
-            summary="Ping the server to check if it's alive.",
-            response_description="A simple pong response.",
-        )
-
-    def ping(self, pong: Optional[str] = None) -> dict:
-        from fred.utils.dateops import datetime_utcnow
-
-        return {
-            "ping_time": datetime_utcnow().isoformat(),
-            "ping_response": pong or "pong",
-        }

fred_oss-0.56.0/src/main/fred/worker/runner/rest/server.py

@@ -1,85 +0,0 @@
-from dataclasses import dataclass
-
-from fastapi import FastAPI, Depends
-
-from fred.settings import logger_manager, get_environ_variable
-from fred.worker.runner.rest.settings import (
-    FRD_RESTAPI_HOST,
-    FRD_RESTAPI_PORT,
-)
-from fred.worker.runner.rest.routers.catalog import RouterCatalog
-from fred.worker.runner.rest.auth import verify_key
-
-logger = logger_manager.get_logger(name=__name__)
-
-
-@dataclass(frozen=True, slots=True)
-class RunnerServer:
-    app: FastAPI
-    include_routers: list[str]
-    exclude_routers: list[str]
-
-    @classmethod
-    def auto(cls, **kwargs) -> "RunnerServer":
-        # Include routers by checking on keyword argument or environment variable
-        include_routers = kwargs.pop("include_routers", None) or get_environ_variable(
-            "FRD_RUNNER_API_INCLUDE_ROUTERS",
-            default=""
-        )
-        if isinstance(include_routers, str):
-            include_routers = [
-                name.upper()
-                for router in include_routers.split(";")
-                if (name := router.strip())
-            ]
-        # Exclude routers by checking on keyword argument or environment variable
-        exclude_routers = kwargs.pop("exclude_routers", None) or get_environ_variable(
-            "FRD_RUNNER_API_EXCLUDE_ROUTERS",
-            default=""
-        )
-        if isinstance(exclude_routers, str):
-            exclude_routers = [
-                name.upper()
-                for router in exclude_routers.split(";")
-                if (name := router.strip())
-            ]
-        # Create FastAPI instance
-        kwargs["dependencies"] = kwargs.get("dependencies", []) + [
-            Depends(verify_key),
-        ]
-        app_instance = FastAPI(**kwargs)
-        return cls(
-            app=app_instance,
-            include_routers=include_routers,
-            exclude_routers=exclude_routers,
-        )
-
-    def __post_init__(self):
-        logger.info("Attempting to register routers...")
-        logger.info("Included routers candidates: %s", self.include_routers or "ALL")
-        logger.info("Excluded routers candidates: %s", self.exclude_routers or "NONE")
-        for router in RouterCatalog:
-            name = router.name.upper()
-            if self.include_routers and name not in self.include_routers:
-                logger.info(f"Skipping router '{name}' as it's not in the include list.")
-                continue
-            if self.exclude_routers and name in self.exclude_routers:
-                logger.info(f"Skipping router '{name}' as it's in the exclude list.")
-                continue
-            logger.info(f"Registering router '{name}'.")
-            self.app.include_router(
-                router.get_router_instance(),
-                **router.get_router_configs(),
-            ) 
-
-    def start(self, **kwargs):
-        import uvicorn
-
-        server_kwargs = {
-            "host": kwargs.pop("host", FRD_RESTAPI_HOST),
-            "port": int(kwargs.pop("port", FRD_RESTAPI_PORT)),
-            "log_level": "info",
-            **kwargs,
-        }
-
-        uvicorn.run(self.app, **server_kwargs)

fred_oss-0.56.0/src/main/fred/worker/runner/rest/settings.py

@@ -1,21 +0,0 @@
-from fred.settings import get_environ_variable, logger_manager
-
-logger = logger_manager.get_logger(name=__name__)
-
-
-FRD_RESTAPI_HOST = get_environ_variable(
-    "FRD_RESTAPI_HOST",
-    default="0.0.0.0"
-)
-FRD_RESTAPI_PORT = int(get_environ_variable(
-    "FRD_RESTAPI_PORT",
-    default=8000
-))
-
-FRD_RESTAPI_TOKEN = get_environ_variable(
-    "FRD_RESTAPI_TOKEN",
-    default=None
-)
-if not FRD_RESTAPI_TOKEN:
-    logger.warning("FRD_RESTAPI_TOKEN not found in environment; using default token 'changeme'.")
-    FRD_RESTAPI_TOKEN = "changeme"