fred-oss 0.12.0__tar.gz → 0.14.0__tar.gz

{fred_oss-0.12.0/src/main/fred_oss.egg-info → fred_oss-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.12.0
+Version: 0.14.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development
@@ -11,6 +11,8 @@ License-File: NOTICE.txt
 Requires-Dist: fire==0.7.1
 Requires-Dist: psutil==7.0.0
 Requires-Dist: redis==6.4.0
+Requires-Dist: fastapi==0.116.2
+Requires-Dist: uvicorn[standard]==0.35.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{fred_oss-0.12.0 → fred_oss-0.14.0}/requirements.txt

@@ -2,6 +2,8 @@
 fire==0.7.1
 # Minimal requirements
 psutil==7.0.0
-# Fred Workers Infra
+# Fred Worker/Runner Infra
 redis==6.4.0
+fastapi==0.116.2
+uvicorn[standard]==0.35.0
 # Databricks Runtime: 16.4 LTS (Python 3.12.3)

{fred_oss-0.12.0 → fred_oss-0.14.0}/src/main/fred/cli/main.py

@@ -18,6 +18,11 @@ class CLIExtensionGroups:
     def runpod(self):
         from fred.integrations.runpod.cli_ext import RunPodExt
         return RunPodExt()
+    
+    @property
+    def runner_server(self):
+        from fred.worker.runner.rest.cli_ext import RunnerServerExt
+        return RunnerServerExt()
 
 
 class CLI(AbstractCLI, CLIExtensionGroups):

fred_oss-0.14.0/src/main/fred/version

@@ -0,0 +1 @@
+0.14.0

fred_oss-0.14.0/src/main/fred/worker/runner/info.py

@@ -0,0 +1,54 @@
+import uuid
+from typing import Optional
+from dataclasses import dataclass
+
+from fred.settings import logger_manager
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerInfo:
+    runner_id: str
+    created_at: str
+    runner_inner_handler_classname: str
+    runner_inner_handler_classpath: str
+    lifetime: int
+    timeout: int
+
+    @classmethod
+    def create(
+        cls,
+        runner_inner_handler_classname: str,
+        runner_inner_handler_classpath: str,
+        runner_id: Optional[str] = None,
+        created_at: Optional[str] = None,
+        lifetime: int = 3600,  # Default to 1 hour
+        timeout: int = 10,  # Default to 10 seconds
+    ) -> "RunnerInfo":
+        from fred.utils.dateops import datetime_utcnow
+        return cls(
+            runner_id=runner_id or str(uuid.uuid4()),
+            runner_inner_handler_classname=runner_inner_handler_classname,
+            runner_inner_handler_classpath=runner_inner_handler_classpath,
+            created_at=created_at or datetime_utcnow().isoformat(),
+            lifetime=lifetime,
+            timeout=timeout,
+        )
+
+    def get_start_event(self, **kwargs) -> dict:
+        runner_id = kwargs.pop("runner_id", self.runner_id) 
+        payload = {
+            "lifetime": self.lifetime,
+            "timeout": self.timeout,
+            "runner_configs": {
+                "id": runner_id,
+                "import_pattern": self.runner_inner_handler_classpath,
+                "handler_classname": self.runner_inner_handler_classname,
+            },
+            **kwargs,
+        }
+        return {
+            "input": payload,
+            "id": runner_id,
+        }

fred_oss-0.14.0/src/main/fred/worker/runner/plugins/_local.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+
+from fred.settings import logger_manager
+from fred.worker.runner.info import RunnerInfo
+from fred.worker.runner.handler import RunnerHandler
+from fred.worker.runner.plugins.interface import PluginInterface
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class LocalPlugin(PluginInterface):
+
+    def _execute(
+            self,
+            runner_info: RunnerInfo,
+            outer_handler: RunnerHandler,
+            **kwargs
+        ):
+        """Execute the runner locally using the provided outer handler.
+        Args:
+            runner_info (RunnerInfo): Information about the runner to execute.
+            outer_handler (RunnerHandler): The outer handler to use for execution.
+            **kwargs: Additional keyword arguments to pass to the execution method implemented by the subclass.
+        """
+        outer_handler.run(event=runner_info.get_start_event(**kwargs))

fred_oss-0.14.0/src/main/fred/worker/runner/plugins/catalog.py

@@ -0,0 +1,15 @@
+import enum
+from dataclasses import dataclass
+
+from fred.settings import logger_manager
+from fred.worker.runner.plugins._local import LocalPlugin
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+class PluginCatalog(enum.Enum):
+    """Enum for the different plugins available in FRED."""
+
+    LOCAL = LocalPlugin.auto()
+    RUNPOD = None  # Placeholder for future RunPod plugin
+    LAMBDA = None  # Placeholder for future AWS Lambda plugin

fred_oss-0.14.0/src/main/fred/worker/runner/plugins/interface.py

@@ -0,0 +1,152 @@
+from dataclasses import dataclass
+from threading import Thread
+from typing import Optional
+
+from redis import Redis
+
+from fred.settings import logger_manager
+from fred.worker.runner.info import RunnerInfo
+from fred.worker.runner.handler import RunnerHandler
+from fred.worker.runner.utils import get_redis_configs_from_payload
+from fred.utils.dateops import datetime_utcnow
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class PluginInterface:
+    """Interface for the different plugins available for FRED Runners."""
+    redis: Redis
+
+    @classmethod
+    def auto(cls, **kwargs) -> "PluginInterface":
+        """Auto-instantiate the plugin interface with a Redis instance.
+        If a Redis instance is not provided, it will create one using configurations
+        extracted from the provided keyword arguments.
+        Args:
+            **kwargs: Keyword arguments that may contain Redis configurations or an existing Redis instance.
+        Returns:
+            PluginInterface: An instance of the PluginInterface with a Redis connection.
+        """
+        redis = kwargs.pop("instance", None) or Redis(**get_redis_configs_from_payload(payload=kwargs, keep=False))
+        return cls(redis=redis)
+
+    def _execute(
+            self,
+            runner_info: RunnerInfo,
+            outer_handler: RunnerHandler,
+            **kwargs
+        ):
+        raise NotImplementedError("This method should be overridden by subclasses.")
+
+    def _monitor(self, runner_info: RunnerInfo, **kwargs):
+        raise NotImplementedError("This method should be overridden by subclasses.")
+
+    def monitor(
+            self,
+            runner_info: RunnerInfo,
+            blocking: bool = False,
+            timeout: Optional[int] = None,
+            **kwargs
+        ) -> Optional[Thread]:
+        """Start monitoring the runner in a separate thread.
+        Args:
+            runner_info (RunnerInfo): Information about the runner to monitor.
+            blocking (bool, optional): Whether to block the main thread until monitoring is complete. Defaults to False.
+            timeout (Optional[int], optional): Timeout in seconds for the monitoring thread. Defaults to None.
+            **kwargs: Additional keyword arguments to pass to the monitoring method.
+        Returns:
+            Optional[Thread]: The thread object for the monitoring thread if not blocking, else None."""
+        # Start monitoring in a separate thread
+        thread = Thread(
+            target=self._monitor,
+            kwargs={
+                "runner_info": runner_info,
+                "blocking": blocking,
+                **kwargs
+            },
+            daemon=True,
+        )
+        thread.start()
+        # If blocking is True, wait for the thread to finish or timeout
+        return thread.join(timeout=timeout) if blocking else thread
+
+    def _execute_wrapper(
+            self,
+            runner_info: RunnerInfo,
+            outer_handler: RunnerHandler,
+            **kwargs
+        ) -> str:
+        """Wrapper method to handle execution and include error logging.
+
+        Since we don't control the implementation of the _execute method in subclasses, we
+        need to wrap it to add error handling and logging.
+
+        Args:
+            runner_info (RunnerInfo): Information about the runner to execute.
+            outer_handler (RunnerHandler): The outer handler to use for execution.
+            **kwargs: Additional keyword arguments to pass to the execution method implemented by the subclass.
+        """
+        runner_id = runner_info.runner_id
+        self.redis.set(f"runner:{runner_id}:status", f"STARTING:{datetime_utcnow().isoformat()}")
+        try:
+            self._execute(
+                    runner_info=runner_info,
+                    outer_handler=outer_handler,
+                    **kwargs
+                )
+        except Exception as e:
+            self.redis.set(f"runner:{runner_id}:status", f"ERROR:{datetime_utcnow().isoformat()}")
+            logger.error(f"Error executing runner '{runner_id}': {e}")
+            raise
+        return runner_id
+
+    def execute(
+            self,
+            runner_info: RunnerInfo,
+            outer_handler: RunnerHandler,
+            wait_for_exec: bool = False,
+            timeout: Optional[int] = None,
+            enable_monitor: bool = False,
+            wait_for_monitor: bool = False,
+            **kwargs
+        ) -> Thread:
+        """Execute the runner using the specified plugin.
+        This method starts the execution of the runner in a separate thread. It can also
+        optionally start a monitoring thread to monitor the runner's status.
+        Args:
+            runner_info (RunnerInfo): Information about the runner to execute.
+            outer_handler (RunnerHandler): The outer handler to use for execution.
+            wait_for_exec (bool, optional): Whether to wait for the execution thread to complete. Defaults to False.
+            timeout (Optional[int], optional): Timeout in seconds for the execution thread. Defaults to None.
+            enable_monitor (bool, optional): Whether to enable monitoring of the runner. Defaults to False.
+            wait_for_monitor (bool, optional): Whether to wait for the monitoring thread to complete. Defaults to False.
+            **kwargs: Additional keyword arguments to pass to the execution and monitoring methods.
+        Returns:
+            Thread: The thread object for the execution.
+        """
+        runner_id = runner_info.runner_id
+        logger.info(f"Starting thread runner '{runner_id}' using plugin '{self.__class__.__name__}'.")
+        thread = Thread(
+            target=self._execute_wrapper,
+            kwargs={
+                "runner_info": runner_info,
+                "outer_handler": outer_handler,
+                **kwargs
+            },
+            daemon=True,
+        )
+        thread.start()
+        if enable_monitor:
+            self.monitor(
+                runner_info=runner_info,
+                blocking=wait_for_monitor,
+                timeout=timeout,
+                **kwargs
+            )
+        else:
+            logger.info(f"Monitoring disabled for runner '{runner_id}'.")
+        if wait_for_exec:
+            logger.info(f"Waiting for execution of runner '{runner_id}' to complete.")
+            thread.join()
+        return thread

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

@@ -0,0 +1,32 @@
+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.14.0/src/main/fred/worker/runner/rest/routers/_runner.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from fred.worker.runner.rest.routers.interface import RouterInterface
+
+
+@dataclass(frozen=True, slots=False)
+class RunnerRouter(RouterInterface):
+
+    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.",
+        )
+
+    def handler_exists(self, classname: str, classpath: str) -> dict:
+        from fred.worker.runner.handler import RunnerHandler
+        from fred.worker.interface import HandlerInterface
+
+        result_payload = {
+            "handler_classname": classname,
+            "handler_classpath": classpath,
+            "exists": False,
+            "is_runner_handler": False,
+            "metadata": {}
+        }
+
+        try:
+            handler = HandlerInterface.find_handler(
+                import_pattern=classpath,
+                handler_classname=classname,
+            )
+            result_payload["is_runner_handler"] = isinstance(handler, RunnerHandler)
+            result_payload["exists"] = True
+            return result_payload
+        except Exception as e:
+            result_payload["metadata"]["error"] = str(e)
+            return result_payload

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

@@ -0,0 +1,18 @@
+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.14.0/src/main/fred/worker/runner/rest/routers/interface.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from fastapi import APIRouter
+
+
+@dataclass(frozen=True, slots=False)
+class RouterInterface:
+    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.14.0/src/main/fred/worker/runner/rest/server.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass
+
+from fastapi import FastAPI
+
+from fred.settings import logger_manager, get_environ_variable
+from fred.worker.runner.rest.routers.catalog import RouterCatalog
+
+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
+        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": "localhost",
+            "port": 8000,
+            "log_level": "info",
+            **kwargs,
+        }
+
+        uvicorn.run(self.app, **server_kwargs)

{fred_oss-0.12.0 → fred_oss-0.14.0/src/main/fred_oss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-oss
-Version: 0.12.0
+Version: 0.14.0
 Summary: FREDOSS
 Home-page: https://fred.fahera.mx
 Author: Fahera Research, Education, and Development
@@ -11,6 +11,8 @@ License-File: NOTICE.txt
 Requires-Dist: fire==0.7.1
 Requires-Dist: psutil==7.0.0
 Requires-Dist: redis==6.4.0
+Requires-Dist: fastapi==0.116.2
+Requires-Dist: uvicorn[standard]==0.35.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{fred_oss-0.12.0 → fred_oss-0.14.0}/src/main/fred_oss.egg-info/SOURCES.txt

@@ -30,7 +30,19 @@ src/main/fred/worker/interface.py
 src/main/fred/worker/runner/__init__.py
 src/main/fred/worker/runner/client.py
 src/main/fred/worker/runner/handler.py
+src/main/fred/worker/runner/info.py
 src/main/fred/worker/runner/utils.py
+src/main/fred/worker/runner/plugins/__init__.py
+src/main/fred/worker/runner/plugins/_local.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/cli_ext.py
+src/main/fred/worker/runner/rest/server.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_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.14.0/src/main/fred_oss.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fire==0.7.1
+psutil==7.0.0
+redis==6.4.0
+fastapi==0.116.2
+uvicorn[standard]==0.35.0

fred_oss-0.12.0/src/main/fred/version

@@ -1 +0,0 @@
-0.12.0

fred_oss-0.12.0/src/main/fred_oss.egg-info/requires.txt

@@ -1,3 +0,0 @@
-fire==0.7.1
-psutil==7.0.0
-redis==6.4.0