fred-oss 0.29.0__tar.gz → 0.31.0__tar.gz

{fred_oss-0.29.0/src/main/fred_oss.egg-info → fred_oss-0.31.0}/PKG-INFO

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

{fred_oss-0.29.0 → fred_oss-0.31.0}/src/main/fred/future/impl.py

@@ -239,9 +239,9 @@ class Future(MonadInterface[A]):
     def pullsync(
             cls,
             future_id: str,
-            delay: float = 0.001,
-            delay_incr: float = 0.001,
-            delay_max: float = 30,
+            retry_delay: float = 0.2,
+            retry_backoff_rate: float = 0.1,
+            retry_delay_max: float = 15,
             timeout: float = FRD_FUTURE_DEFAULT_EXPIRATION,
             on_complete: Optional[CallbackInterface] = None,
             **kwargs
@@ -252,9 +252,9 @@ class Future(MonadInterface[A]):
 
         Args:
             future_id (str): The unique identifier of the future to be pulled.
-            delay (float): Initial delay between checks for the future's completion.
-            delay_incr (float): Incremental increase in delay after each check.
-            delay_max (float): Maximum delay between checks.
+            retry_delay (float): Initial delay between checks for the future's completion.
+            retry_backoff_rate (float): Incremental increase in delay after each check.
+            retry_delay_max (float): Maximum delay between checks.
             timeout (float): Maximum time to wait for the future to complete.
             on_complete (Optional[CallbackInterface]): An optional callback to be executed
                                                       when the future completes.
@@ -267,9 +267,9 @@ class Future(MonadInterface[A]):
         return cls(
             function=lambda: pull_future_result(
                 future_id=future_id,
-                delay=delay,
-                delay_incr=delay_incr,
-                delay_max=delay_max,
+                retry_delay=retry_delay,
+                retry_backoff_rate=retry_backoff_rate,
+                retry_delay_max=retry_delay_max,
                 timeout=timeout,
             ),
             on_complete=on_complete,

{fred_oss-0.29.0 → fred_oss-0.31.0}/src/main/fred/future/utils.py

@@ -8,9 +8,9 @@ A = TypeVar("A")
 
 def pull_future_result(
         future_id: str,
-        delay: float = 0.001,
-        delay_incr: float = 0.001,
-        delay_max: float = 30,
+        retry_delay: float = 0.2,
+        retry_backoff_rate: float = 0.1,
+        retry_delay_max: float = 15,
         timeout: float = FRD_FUTURE_DEFAULT_EXPIRATION,
     ) -> A:
     from fred.future.impl import FutureResult, FutureUndefinedInProgress, FutureUndefinedPending
@@ -25,15 +25,15 @@ def pull_future_result(
             return value.resolve()
         case FutureUndefinedPending() | FutureUndefinedInProgress():
             # If the future is not yet defined, wait for it to complete
-            time.sleep(delay)
+            time.sleep(retry_delay)
             # Increase the delay for the next check to avoid busy waiting (exponential backoff) capped at delay_max
             return pull_future_result(
                 future_id=future_id,
-                delay=(delay + delay_incr) if delay < delay_max else delay_max,
-                delay_incr=delay,
-                delay_max=delay_max,
+                retry_delay=min(retry_delay * (1 + retry_backoff_rate), retry_delay_max),
+                retry_backoff_rate=retry_backoff_rate,
+                retry_delay_max=retry_delay_max,
                 # TODO: Consider using a more precise timeout mechanism based on elapsed time
-                timeout=timeout - delay,
+                timeout=timeout - retry_delay,
             )
         case _:
             raise ValueError(f"Unknown future state for ID '{future_id}'")

fred_oss-0.31.0/src/main/fred/version

@@ -0,0 +1 @@
+0.31.0

{fred_oss-0.29.0 → fred_oss-0.31.0}/src/main/fred/worker/interface.py

@@ -139,14 +139,14 @@ class HandlerInterface:
         return json.loads(metadata_serialized)
 
     @overload
-    def run(self, event: dict, as_future: bool = True) -> Future[dict]:
+    def run(self, event: dict, as_future: bool = True, future_id: Optional[str] = None) -> Future[dict]:
         ...
 
     @overload
-    def run(self, event: dict, as_future: bool = False) -> dict:
+    def run(self, event: dict, as_future: bool = False, future_id: Optional[str] = None) -> dict:
         ...
 
-    def run(self, event: dict, as_future: bool = False) -> dict | Future[dict]:
+    def run(self, event: dict, as_future: bool = False, future_id: Optional[str] = None) -> dict | Future[dict]:
         """Process an incoming event and return a structured response.
         The event is expected to be a dictionary with at least an 'id' and 'input' keys.
         The 'input' key should contain the payload to be processed.
@@ -158,7 +158,7 @@ class HandlerInterface:
                 If requested as a Future, returns a Future that will resolve to the response dictionary.
         """
         if as_future:
-            return Future(function=lambda: self.run(event=event, as_future=False))
+            return Future(function=lambda: self.run(event=event, as_future=False), future_id=future_id)
         # Extract payload and event ID
         payload = event.get("input", {})
         job_event_identifier = event.get("id")

fred_oss-0.31.0/src/main/fred/worker/runner/backend.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+
+from fred.settings import logger_manager
+from fred.dao.comp.catalog import FredKeyVal, FredQueue
+from fred.dao.service.catalog import ServiceCatalog
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=False)
+class RunnerBackend:
+    keyval: FredKeyVal
+    queue: FredQueue
+
+    @classmethod
+    def auto(cls, service_name: str, **kwargs) -> 'RunnerBackend':
+        service = ServiceCatalog[service_name.upper()]
+        match service:
+            case ServiceCatalog.REDIS:
+                from fred.dao.service.utils import get_redis_configs_from_payload
+                service_kwargs = get_redis_configs_from_payload(kwargs)
+            case ServiceCatalog.STDLIB:
+                service_kwargs = {}
+            case _:
+                logger.error(f"Unknown service '{service_name}'... will attempt to use provided kwargs as-is.")
+                service_kwargs = kwargs
+        components = service.component_catalog(**service_kwargs)
+        return cls(
+            keyval=components.KEYVAL.value,
+            queue=components.QUEUE.value,
+        )

fred_oss-0.31.0/src/main/fred/worker/runner/client.py

@@ -0,0 +1,144 @@
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+from fred.future import Future
+from fred.future.result import FutureResult
+from fred.dao.comp.catalog import FredQueue
+from fred.worker.runner.status import RunnerStatus
+from fred.worker.runner.signal import RunnerSignal
+from fred.worker.runner.backend import RunnerBackend
+from fred.worker.runner.model.catalog import RunnerModelCatalog
+from fred.worker.runner.settings import (
+    FRD_RUNNER_BACKEND,
+    FRD_RUNNER_REQUEST_QUEUE,
+    FRD_RUNNER_RESPONSE_QUEUE,
+)
+from fred.settings import logger_manager
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerClient:
+    _runner_backend: RunnerBackend
+    req_queue: FredQueue
+    res_queue: FredQueue
+
+
+    @classmethod
+    def auto(
+            cls,
+            queue_slug: Optional[str] = None,
+            service_name: Optional[str] = None,
+            **kwargs
+        ) -> "RunnerClient":
+        queue_slug = queue_slug or kwargs.pop("queue_slug", None) or (
+            logger.warning("Queue slug not specified; defaulting to: 'demo'")
+            or "demo"
+        )
+        queue_name_request = FRD_RUNNER_REQUEST_QUEUE or f"req:{queue_slug}"
+        queue_name_response = FRD_RUNNER_RESPONSE_QUEUE or f"res:{queue_slug}"
+        runner_backend = RunnerBackend.auto(
+            service_name=service_name or FRD_RUNNER_BACKEND,
+            **kwargs
+        )
+        return cls(
+            _runner_backend=runner_backend,
+            req_queue=runner_backend.queue(name=queue_name_request),
+            res_queue=runner_backend.queue(name=queue_name_response),
+        )
+
+    @property
+    def PING(self):
+        return self.signal(RunnerSignal.PING)
+
+    @property
+    def STOP(self):
+        return self.signal(RunnerSignal.STOP)
+
+    def signal(self, signal: str | RunnerSignal):
+        signal = RunnerSignal[signal.upper()] if isinstance(signal, str) else signal
+        return signal.send(self.req_queue)
+
+    def runner_status(self, runner_id: str) -> RunnerStatus:
+        runner_status=self._runner_backend.keyval(
+                key=RunnerStatus.get_key(runner_id=runner_id)
+            )
+        if not (value := runner_status.get()):
+            logger.warning(f"No status found for runner_id: '{runner_id}'")
+            return RunnerStatus.UNDEFINED
+        return RunnerStatus.parse_value(value=value)
+
+    def send(
+            self,
+            item: dict,
+            req_uuid_hash: bool = False,
+            item_uuid_hash: bool = False,
+    ) -> str:
+        item_instance = RunnerModelCatalog.ITEM.value.uuid(payload=item, uuid_hash=item_uuid_hash)
+        request = item_instance.as_request(
+            use_hash=req_uuid_hash,
+            request_id=item.get("request_id"),
+        )
+        request.dispatch(request_queue=self.req_queue)
+        return request.request_id
+    
+    @staticmethod
+    def fetch_status(request_id: str) -> Optional[str]:
+        return FutureResult._get_status_key(future_id=request_id).get()
+
+    def pullsync(
+            self,
+            request_id: str,
+            retry_sync: int = 10,
+            retry_delay: float = 0.2,
+            retry_backoff_rate: float = 0.1,
+            **kwargs,
+    ) -> Future:
+        # TODO: Once the broadcast method is implemented, we can add a warning notice regarding
+        # the pullsync metho adding extra load to the backend service
+        future = Future(
+            function=self._is_ready_for_pullsync,
+            request_id=request_id,
+            retry_sync=retry_sync,
+            retry_delay=retry_delay,
+            retry_backoff_rate=retry_backoff_rate,
+            fail=True,  # Always fail inside the future to propagate the exception
+        )
+        return future.flat_map(
+            lambda _: Future.pullsync(future_id=request_id, **kwargs)
+        )
+
+    def _is_ready_for_pullsync(
+            self,
+            request_id: str,
+            retry_sync: int = 10,
+            retry_delay: float = 0.2,
+            retry_backoff_rate: float = 0.1,
+            fail: bool = False,
+    ) -> bool:
+        if not self.fetch_status(request_id=request_id):
+            logger.info(f"No status found for request_id '{request_id}'")
+            retry_kwargs = {
+                "request_id": request_id,
+                "retry_sync": retry_sync - 1,
+                "retry_delay": retry_delay * (1 + retry_backoff_rate),  # Exponential backoff
+                "retry_backoff_rate": retry_backoff_rate,
+                "fail": fail,
+            }
+            if retry_sync:
+                time.sleep(retry_delay)
+                return self._is_ready_for_pullsync(**retry_kwargs)
+            elif fail:
+                logger.error(f"Failed to fetch status for request_id '{request_id}' after retries.")
+                raise ValueError(f"No status found for request_id '{request_id}'")
+            else:
+                return False
+        return True
+
+    def fetch_result(self, request_id: str, now: bool = False, timeout: Optional[float] = None) -> Optional[dict]:
+        future = self.pullsync(request_id=request_id)
+        if now:
+            return future.getwhatevernow()
+        return future.wait_and_resolve(timeout=timeout)

fred_oss-0.31.0/src/main/fred/worker/runner/handler.py

@@ -0,0 +1,191 @@
+import uuid
+import json
+from dataclasses import dataclass
+from typing import Optional
+
+from fred.future import Future
+from fred.monad.catalog import EitherMonad
+from fred.utils.dateops import datetime_utcnow
+from fred.dao.comp.catalog import FredQueue
+from fred.worker.runner.settings import FRD_RUNNER_BACKEND
+from fred.worker.runner.backend import RunnerBackend
+from fred.worker.runner.model.catalog import RunnerModelCatalog
+from fred.worker.interface import HandlerInterface
+from fred.worker.runner.status import RunnerStatus
+
+from fred.settings import logger_manager
+
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=False)
+class RunnerHandler(HandlerInterface):
+    
+    def __post_init__(self):
+        super().__post_init__()
+        logger.info("Fred-Runner outer-handler initialized using Fred-Worker interface.")
+
+    @staticmethod 
+    def _runner_process(
+            item: dict,
+            runner: HandlerInterface,
+            item_id: str,
+            request_id: str,
+    ) -> Future[dict]:
+        logger.info(f"Processing item '{item_id}' provided by request-id: {request_id}")
+        return runner.run(
+            event={
+                "id": item_id,
+                "input": item
+            },
+            as_future=True,
+            future_id=request_id,
+        )
+
+    def _runner_loop(
+            self,
+            runner: HandlerInterface,
+            req_queue: FredQueue,
+            lifespan: int,
+            timeout: int,
+            res_queue: Optional[FredQueue] = None,
+    ) -> dict:
+        start_time = datetime_utcnow()
+        last_processed_time = datetime_utcnow()
+        while (elapsed_seconds := (datetime_utcnow() - start_time).total_seconds()):
+            if elapsed_seconds > lifespan:
+                logger.info("Lifespan exceeded; exiting runner loop.")
+                break
+            if (idle_seconds := (datetime_utcnow() - last_processed_time).total_seconds()) > timeout:
+                logger.info(f"Idle time ({idle_seconds}) exceeded timeout ({timeout}); exiting runner loop.")
+                break
+            # Fetch item from Redis queue 
+            try:
+                message = req_queue.pop()
+                # If no item, iterate again
+                if not message:
+                    continue
+            except Exception as e:
+                logger.error(f"Error fetching item from Redis queue '{req_queue}': {e}")
+                continue
+            # Handle special signals
+            match message:
+                case "STOP" | "SHUTDOWN" | "TERMINATE":
+                    logger.info("Received STOP signal; exiting runner loop.")
+                    break
+                case "PING":
+                    logger.info("Received PING signal; continuing.")
+                    last_processed_time = datetime_utcnow()
+                    continue
+                case _:
+                    pass
+            try:
+                item = json.loads(message)
+                item_id = item.get("item_id") or (
+                    logger.warning("No item_id provided in item-payload; generating a new one using UUID5 hash.")
+                    or str(uuid.uuid5(uuid.NAMESPACE_OID, message))
+                )
+                # The request_id is used as the future_id for tracking purposes
+                request_id = item.get("request_id") or (
+                    logger.warning(f"No request_id provided in item-payload; using the item_id '{item_id}' instead.")
+                    or item_id
+                )
+            except Exception as e:
+                logger.error(f"Error decoding or parsing item from Redis: {e}")
+                continue
+            # Process item using runner and handle result
+            future = self._runner_process(item=item, runner=runner, item_id=item_id, request_id=request_id).map(
+                lambda res: res if isinstance(res, str) else json.dumps(res, default=str)
+            )
+            match future.wait():
+                case EitherMonad.Right(value):
+                    if res_queue:
+                        logger.debug(f"Processed item ID '{item_id}' on request ID '{request_id}' and pushed result to response queue.")
+                        res_queue.add(value)
+                case EitherMonad.Left(error):
+                    logger.error(f"Error processing item ID '{item_id}' on request ID '{request_id}': {error}")
+                    continue
+                case _:
+                    logger.error(f"Unexpected result processing item ID '{item_id}' on request ID '{request_id}': {future}")
+                    continue
+            last_processed_time = datetime_utcnow()
+        return {
+            "started_at": start_time.isoformat(),
+            "stopped_at": datetime_utcnow().isoformat(),
+            "total_elapsed_seconds": (datetime_utcnow() - start_time).total_seconds(),
+            "last_processed_at": last_processed_time.isoformat(),
+            "idle_seconds": (datetime_utcnow() - last_processed_time).total_seconds(),
+        }
+ 
+
+    def handler(self, payload: dict) -> dict:
+        # Configure the backend service abstraction (e.g., Redis)
+        runner_backend = RunnerBackend.auto(
+            service_name=payload.pop("runner_backend", None) or FRD_RUNNER_BACKEND,
+            **payload.pop("runner_backend_configs", {}),
+        )
+        # Outer handler model instance
+        spec = RunnerModelCatalog.RUNNER_SPEC.value.from_payload(payload=payload)
+        
+        # Determine request and response queues to use for this runner instance
+        req_queue = runner_backend.queue(name=spec.request_queue_name)
+        res_queue = runner_backend.queue(name=spec.response_queue_name) \
+            if spec.use_response_queue else None
+        # Get runner (inner handler) instance and ID
+        # The 'outer' handler delegates the processing of tasks to the 'inner' handler
+        # and is responsible for managing the lifecycle and updating the status of the runner
+        runner = spec.inner.get_handler()
+        runner_id = spec.runner_id
+        runner_status = runner_backend.keyval(
+            key=RunnerStatus.get_key(runner_id=runner_id)
+        )
+        logger.info(f"Starting runner with ID '{runner_id}' using request-queue '{req_queue.name}'")
+        runner_status.set(
+            value=RunnerStatus.STARTED.get_val(),
+            expire=None,
+        )
+        runner_loop = Future(
+            function=self._runner_loop,
+            runner=runner,
+            req_queue=req_queue,
+            lifespan=spec.lifetime,
+            timeout=spec.timeout,
+            res_queue=res_queue,
+            # The runner_id is used as the future_id for tracking purposes
+            future_id=runner_id,
+        )
+        runner_status.set(
+            value=RunnerStatus.RUNNING.get_val(),
+            expire=None,
+        )
+        results = {
+            "runner_id": runner_id,
+            "runner_started_at": datetime_utcnow().isoformat(),
+            "runner_pending_requests": req_queue.size(),
+        }
+        match runner_loop.wait():
+            case EitherMonad.Right(meta):
+                results["runner_status"] = "success"
+                results["metadata"] = meta
+            case EitherMonad.Left(error):
+                results["runner_status"] = "failure"
+                results["metadata"] = {
+                    "error": str(error)
+                }
+            case _:
+                results["runner_status"] = "unexpected"
+                results["metadata"] = {
+                    "error": "Unexpected result from runner loop"
+                }
+        results["pending_requests"] = pending_requests = req_queue.size()
+        runner_status.set(
+            value=RunnerStatus.STOPPED.get_val(str(pending_requests)),
+            expire=3600,  # Keep the stopped status for 1 hour
+        )
+        if pending_requests:
+            logger.warning(f"Runner '{runner_id}' stopped with {pending_requests} pending items still in the queue: '{req_queue.name}'")
+        else:
+            logger.info(f"Runner '{runner_id}' stopped with no pending items in the queue: '{req_queue.name}'")
+
+        return results

fred_oss-0.31.0/src/main/fred/worker/runner/model/_handler.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+from fred.settings import logger_manager
+from fred.worker.interface import HandlerInterface
+from fred.worker.runner.model.interface import ModelInterface
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=False)
+class Handler(ModelInterface):
+    classname: str
+    classpath: str
+    kwargs: dict
+
+    def get_handler(self) -> HandlerInterface:
+        return HandlerInterface.find_handler(
+            handler_classname=self.classname,
+            import_pattern=self.classpath,
+            **self.kwargs,
+        )

fred_oss-0.31.0/src/main/fred/worker/runner/model/_item.py

@@ -0,0 +1,46 @@
+import json
+import uuid
+from typing import Optional
+
+from pydantic.dataclasses import dataclass
+
+from fred.utils.dateops import datetime_utcnow
+from fred.worker.runner.model._request import RunnerRequest
+from fred.worker.runner.model.interface import ModelInterface
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerItem(ModelInterface):
+    item_id: str
+    item_created_at: str
+    item_payload: dict
+
+    @classmethod
+    def uuid(cls, payload: dict, uuid_hash: bool = False) -> "RunnerItem":
+        item_id = payload.get("item_id") or (
+            str(uuid.uuid5(uuid.NAMESPACE_DNS, json.dumps(payload, default=str)))
+            if uuid_hash else str(uuid.uuid4())
+        )
+        return cls(
+            item_id=item_id,
+            item_created_at=datetime_utcnow().isoformat(),
+            item_payload=payload
+        )
+    
+    def as_payload(self) -> dict:
+        return {
+            "item_id": self.item_id,
+            "item_created_at": self.item_created_at,
+            **self.item_payload,
+        }
+    
+    def as_request(
+            self,
+            use_hash: bool = False,
+            request_id: Optional[str] = None
+    ) -> RunnerRequest:
+        return RunnerRequest.uuid(
+            payload=self.as_payload(),
+            request_id=request_id,
+            uuid_hash=use_hash,
+        )

fred_oss-0.31.0/src/main/fred/worker/runner/model/_request.py

@@ -0,0 +1,41 @@
+import uuid
+import json
+from typing import Optional
+
+from pydantic.dataclasses import dataclass
+
+from fred.dao.comp.catalog import FredQueue
+from fred.worker.runner.model.interface import ModelInterface
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerRequest(ModelInterface):
+    request_id: str
+    payload: dict
+
+    @classmethod
+    def uuid(
+            cls,
+            payload: dict,
+            uuid_hash: bool = False,
+            request_id: Optional[str] = None,
+    ) -> "RunnerRequest":
+        request_id = request_id or (
+            str(uuid.uuid5(uuid.NAMESPACE_OID, json.dumps(payload, default=str)))
+            if uuid_hash else str(uuid.uuid4())
+        )
+        return cls(request_id=request_id, payload=payload)
+    
+    def as_payload(self) -> dict:
+        return {
+            "request_id": self.request_id,
+            **self.payload,
+        }
+    
+    def dispatch(self, request_queue: FredQueue, **kwargs):
+        serialization_kwargs = {
+            "default": str,
+            **kwargs
+        }
+        request = json.dumps(self.as_payload(), **serialization_kwargs)
+        return request_queue.add(request)

fred_oss-0.31.0/src/main/fred/worker/runner/model/_runner_spec.py

@@ -0,0 +1,88 @@
+import uuid
+from dataclasses import dataclass
+
+from fred.settings import logger_manager
+from fred.utils.dateops import datetime_utcnow
+from fred.worker.runner.model._handler import Handler
+from fred.worker.runner.model.interface import ModelInterface
+from fred.worker.runner.settings import (
+    FRD_RUNNER_REQUEST_QUEUE,
+    FRD_RUNNER_RESPONSE_QUEUE,
+)
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+
+@dataclass(frozen=True, slots=False)
+class RunnerSpec(ModelInterface):
+    runner_id: str
+    created_at: str
+    queue_slug: str
+    inner: Handler
+    use_response_queue: bool = False
+    lifetime: int = 3600  # Default to 1 hour if not specified
+    timeout: int = 30  # Default to 30 seconds if not specified
+
+    @classmethod
+    def auto(cls, **kwargs) -> "RunnerSpec":
+        kwargs["runner_id"] = kwargs.get("runner_id", str(uuid.uuid4()))
+        return cls.from_payload(payload=kwargs)
+
+    @classmethod
+    def from_payload(cls, payload: dict) -> "RunnerSpec":
+        inner_handler_kwargs = {
+            "classname": payload.pop("handler_classname", None) or (
+                logger.warning("No handler_classname provided; defaulting to: 'HandlerInterface'")
+                or "HandlerInterface"
+            ),
+            "classpath": payload.pop("handler_classpath", None) or (
+                logger.warning("No handler_classpath provided; defaulting to: 'fred.worker.interface'")
+                or "fred.worker.interface"
+            ),
+            "kwargs": payload.pop("handler_kwargs", {}),
+            **payload.pop("handler_configs", {})
+        }
+        runner_id = payload.pop("runner_id", None) or (
+            logger.warning("No runner_id provided; generating a new one using UUID4.")
+            or str(uuid.uuid4())
+        )
+        return cls(
+            runner_id=runner_id,
+            created_at=datetime_utcnow().isoformat(),
+            queue_slug=payload.pop("queue_slug", None) or (
+                logger.warning("Queue slug not specified; defaulting to: 'demo'")
+                or "demo"
+            ),
+            inner=Handler(**inner_handler_kwargs),
+            use_response_queue=payload.pop("use_response_queue", False),
+            lifetime=payload.pop("lifetime", 3600),
+            timeout=payload.pop("timeout", 30),
+        )
+    
+    def as_dict(self) -> dict:
+        return {
+            "runner_id": self.runner_id,
+            "created_at": self.created_at,
+            "queue_slug": self.queue_slug,
+            "handler_classname": self.inner.classname,
+            "handler_classpath": self.inner.classpath,
+            "handler_kwargs": self.inner.kwargs,
+            "use_response_queue": self.use_response_queue,
+            "lifetime": self.lifetime,
+            "timeout": self.timeout,
+        }
+    
+    def as_event(self) -> dict:
+        return {
+            "id": self.runner_id,
+            "input": self.as_dict(),
+        }
+    
+    @property
+    def request_queue_name(self) -> str:
+        return FRD_RUNNER_REQUEST_QUEUE or f"req:{self.queue_slug}"
+    
+    @property
+    def response_queue_name(self) -> str:
+        return FRD_RUNNER_RESPONSE_QUEUE or f"res:{self.queue_slug}"