tetra-rp 0.6.0__tar.gz → 0.8.0__tar.gz

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tetra_rp
-Version: 0.6.0
+Version: 0.8.0
 Summary: A Python library for distributed inference and serving of machine learning models
 Author-email: Marut Pandya <pandyamarut@gmail.com>, Patrick Rachford <prachford@icloud.com>, Dean Quinanola <dean.quinanola@runpod.io>
 License: MIT

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tetra_rp"
-version = "0.6.0"
+version = "0.8.0"
 description = "A Python library for distributed inference and serving of machine learning models"
 authors = [
     { name = "Marut Pandya", email = "pandyamarut@gmail.com" },

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/src/tetra_rp/client.py

@@ -1,18 +1,19 @@
+import inspect
 import logging
 from functools import wraps
 from typing import List, Optional
-from .core.resources import ServerlessResource, ResourceManager, NetworkVolume
-from .stubs import stub_resource
 
+from .core.resources import ResourceManager, ServerlessResource
+from .execute_class import create_remote_class
+from .stubs import stub_resource
 
 log = logging.getLogger(__name__)
 
 
 def remote(
     resource_config: ServerlessResource,
-    dependencies: List[str] = None,
-    system_dependencies: List[str] = None,
-    mount_volume: Optional[NetworkVolume] = None,
+    dependencies: Optional[List[str]] = None,
+    system_dependencies: Optional[List[str]] = None,
     **extra,
 ):
     """
@@ -25,8 +26,6 @@ def remote(
             to be provisioned or used.
         dependencies (List[str], optional): A list of pip package names to be installed in the remote
             environment before executing the function. Defaults to None.
-        mount_volume (NetworkVolume, optional): Configuration for creating and mounting a network volume.
-            Should contain 'size', 'datacenter_id', and 'name' keys. Defaults to None.
         extra (dict, optional): Additional parameters for the execution of the resource. Defaults to an empty dict.
 
     Returns:
@@ -46,26 +45,26 @@ def remote(
     ```
     """
 
-    def decorator(func):
-        @wraps(func)
-        async def wrapper(*args, **kwargs):
-            # Create netowrk volume if mount_volume is provided
-            if mount_volume:
-                try:
-                    network_volume = await mount_volume.deploy()
-                    resource_config.networkVolumeId = network_volume.id
-                except Exception as e:
-                    log.error(f"Failed to create or mount network volume: {e}")
-                    raise
-
-            resource_manager = ResourceManager()
-            remote_resource = await resource_manager.get_or_deploy_resource(
-                resource_config
+    def decorator(func_or_class):
+        if inspect.isclass(func_or_class):
+            # Handle class decoration
+            return create_remote_class(
+                func_or_class, resource_config, dependencies, system_dependencies, extra
             )
+        else:
+            # Handle function decoration (unchanged)
+            @wraps(func_or_class)
+            async def wrapper(*args, **kwargs):
+                resource_manager = ResourceManager()
+                remote_resource = await resource_manager.get_or_deploy_resource(
+                    resource_config
+                )
 
-            stub = stub_resource(remote_resource, **extra)
-            return await stub(func, dependencies, system_dependencies, *args, **kwargs)
+                stub = stub_resource(remote_resource, **extra)
+                return await stub(
+                    func_or_class, dependencies, system_dependencies, *args, **kwargs
+                )
 
-        return wrapper
+            return wrapper
 
     return decorator

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/src/tetra_rp/core/api/runpod.py

@@ -3,11 +3,12 @@ Direct GraphQL communication with Runpod API.
 Bypasses the outdated runpod-python SDK limitations.
 """
 
-import os
 import json
-import aiohttp
-from typing import Dict, Any, Optional
 import logging
+import os
+from typing import Any, Dict, Optional
+
+import aiohttp
 
 log = logging.getLogger(__name__)
 
@@ -267,31 +268,12 @@ class RunpodRestClient:
             raise Exception(f"HTTP request failed: {e}")
 
     async def create_network_volume(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Create a network volume in Runpod.
+        """Create a network volume in Runpod."""
+        log.debug(f"Creating network volume: {payload.get('name', 'unnamed')}")
 
-        Args:
-            datacenter_id (str): The ID of the datacenter where the volume will be created.
-            name (str): The name of the network volume.
-            size_gb (int): The size of the volume in GB.
-
-        Returns:
-            Dict[str, Any]: The created network volume details.
-        """
-        datacenter_id = payload.get("dataCenterId")
-        if hasattr(datacenter_id, "value"):
-            # If datacenter_id is an enum, get its value
-            datacenter_id = datacenter_id.value
-        data = {
-            "dataCenterId": datacenter_id,
-            "name": payload.get("name"),
-            "size": payload.get("size"),
-        }
-        url = f"{RUNPOD_REST_API_URL}/networkvolumes"
-
-        log.debug(f"Creating network volume: {data.get('name', 'unnamed')}")
-
-        result = await self._execute_rest("POST", url, data)
+        result = await self._execute_rest(
+            "POST", f"{RUNPOD_REST_API_URL}/networkvolumes", payload
+        )
 
         log.info(
             f"Created network volume: {result.get('id', 'unknown')} - {result.get('name', 'unnamed')}"

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/src/tetra_rp/core/resources/network_volume.py

@@ -4,6 +4,7 @@ from typing import Optional
 
 from pydantic import (
     Field,
+    field_serializer,
 )
 
 from ..api.runpod import RunpodRestClient
@@ -20,8 +21,6 @@ class DataCenter(str, Enum):
     """
 
     EU_RO_1 = "EU-RO-1"
-    US_WA_1 = "US-WA-1"
-    US_CA_1 = "US-CA-1"
 
 
 class NetworkVolume(DeployableResource):
@@ -33,10 +32,20 @@ class NetworkVolume(DeployableResource):
 
     """
 
-    dataCenterId: Optional[DataCenter] = None
+    # Internal fixed value
+    dataCenterId: DataCenter = Field(default=DataCenter.EU_RO_1, frozen=True)
+
     id: Optional[str] = Field(default=None)
     name: Optional[str] = None
-    size: Optional[int] = None  # Size in GB
+    size: Optional[int] = Field(default=10, gt=0)  # Size in GB
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}:{self.id}"
+
+    @field_serializer("dataCenterId")
+    def serialize_data_center_id(self, value: Optional[DataCenter]) -> Optional[str]:
+        """Convert DataCenter enum to string."""
+        return value.value if value is not None else None
 
     @property
     def is_created(self) -> bool:
@@ -79,17 +88,17 @@ class NetworkVolume(DeployableResource):
         try:
             # If the resource is already deployed, return it
             if self.is_deployed():
-                log.debug(
-                    f"Network volume {self.id} is already deployed. Mounting existing volume."
-                )
-                log.info(f"Mounted existing network volume: {self.id}")
+                log.debug(f"{self} exists")
                 return self
 
             # Create the network volume
-            self = await self.create_network_volume()
+            async with RunpodRestClient() as client:
+                # Create the network volume
+                payload = self.model_dump(exclude_none=True)
+                result = await client.create_network_volume(payload)
 
-            if self.is_deployed():
-                return self
+            if volume := self.__class__(**result):
+                return volume
 
             raise ValueError("Deployment failed, no volume was created.")
 

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/src/tetra_rp/core/resources/serverless.py

@@ -1,27 +1,27 @@
 import asyncio
 import logging
-from typing import Any, Dict, List, Optional
 from enum import Enum
+from typing import Any, Dict, List, Optional
+
 from pydantic import (
+    BaseModel,
+    Field,
     field_serializer,
     field_validator,
     model_validator,
-    BaseModel,
-    Field,
 )
-
 from runpod.endpoint.runner import Job
 
 from ..api.runpod import RunpodGraphQLClient
 from ..utils.backoff import get_backoff_delay
-
-from .cloud import runpod
 from .base import DeployableResource
-from .template import PodTemplate, KeyValuePair
-from .gpu import GpuGroup
+from .cloud import runpod
+from .constants import CONSOLE_URL
 from .cpu import CpuInstanceType
 from .environment import EnvironmentVars
-from .constants import CONSOLE_URL
+from .gpu import GpuGroup
+from .network_volume import NetworkVolume
+from .template import KeyValuePair, PodTemplate
 
 
 # Environment variables are loaded from the .env file
@@ -62,7 +62,15 @@ class ServerlessResource(DeployableResource):
     Base class for GPU serverless resource
     """
 
-    _input_only = {"id", "cudaVersions", "env", "gpus", "flashboot", "imageName"}
+    _input_only = {
+        "id",
+        "cudaVersions",
+        "env",
+        "gpus",
+        "flashboot",
+        "imageName",
+        "networkVolume",
+    }
 
     # === Input-only Fields ===
     cudaVersions: Optional[List[CudaVersion]] = []  # for allowedCudaVersions
@@ -71,6 +79,8 @@ class ServerlessResource(DeployableResource):
     gpus: Optional[List[GpuGroup]] = [GpuGroup.ANY]  # for gpuIds
     imageName: Optional[str] = ""  # for template.imageName
 
+    networkVolume: Optional[NetworkVolume] = None
+
     # === Input Fields ===
     executionTimeoutMs: Optional[int] = None
     gpuCount: Optional[int] = 1
@@ -142,6 +152,10 @@ class ServerlessResource(DeployableResource):
         if self.flashboot:
             self.name += "-fb"
 
+        if self.networkVolume and self.networkVolume.is_created:
+            # Volume already exists, use its ID
+            self.networkVolumeId = self.networkVolume.id
+
         if self.instanceIds:
             return self._sync_input_fields_cpu()
         else:
@@ -177,6 +191,21 @@ class ServerlessResource(DeployableResource):
 
         return self
 
+    async def _ensure_network_volume_deployed(self) -> None:
+        """
+        Ensures network volume is deployed and ready.
+        Updates networkVolumeId with the deployed volume ID.
+        """
+        if self.networkVolumeId:
+            return
+
+        if not self.networkVolume:
+            log.info(f"{self.name} requires a default network volume")
+            self.networkVolume = NetworkVolume(name=f"{self.name}-volume")
+
+        if deployedNetworkVolume := await self.networkVolume.deploy():
+            self.networkVolumeId = deployedNetworkVolume.id
+
     def is_deployed(self) -> bool:
         """
         Checks if the serverless resource is deployed and available.
@@ -202,6 +231,9 @@ class ServerlessResource(DeployableResource):
                 log.debug(f"{self} exists")
                 return self
 
+            # NEW: Ensure network volume is deployed first
+            await self._ensure_network_volume_deployed()
+
             async with RunpodGraphQLClient() as client:
                 payload = self.model_dump(exclude=self._input_only, exclude_none=True)
                 result = await client.create_endpoint(payload)

tetra_rp-0.8.0/src/tetra_rp/execute_class.py

@@ -0,0 +1,178 @@
+import base64
+import inspect
+import logging
+import textwrap
+import uuid
+from typing import List, Type, Optional
+
+import cloudpickle
+
+from .core.resources import ResourceManager, ServerlessResource
+from .protos.remote_execution import FunctionRequest
+from .stubs import stub_resource
+
+log = logging.getLogger(__name__)
+
+
+def extract_class_code_simple(cls: Type) -> str:
+    """Extract clean class code without decorators and proper indentation"""
+    try:
+        # Get source code
+        source = inspect.getsource(cls)
+
+        # Split into lines
+        lines = source.split("\n")
+
+        # Find the class definition line (starts with 'class' and contains ':')
+        class_start_idx = -1
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            if stripped.startswith("class ") and ":" in stripped:
+                class_start_idx = i
+                break
+
+        if class_start_idx == -1:
+            raise ValueError("Could not find class definition")
+
+        # Take lines from class definition onwards (ignore everything before)
+        class_lines = lines[class_start_idx:]
+
+        # Remove empty lines at the end
+        while class_lines and not class_lines[-1].strip():
+            class_lines.pop()
+
+        # Join back and dedent to remove any leading indentation
+        class_code = "\n".join(class_lines)
+        class_code = textwrap.dedent(class_code)
+
+        # Validate the code by trying to compile it
+        compile(class_code, "<string>", "exec")
+
+        log.debug(f"Successfully extracted class code for {cls.__name__}")
+        return class_code
+
+    except Exception as e:
+        log.warning(f"Could not extract class code for {cls.__name__}: {e}")
+        log.warning("Falling back to basic class structure")
+
+        # Enhanced fallback: try to preserve method signatures
+        fallback_methods = []
+        for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
+            try:
+                sig = inspect.signature(method)
+                fallback_methods.append(f"    def {name}{sig}:")
+                fallback_methods.append("        pass")
+                fallback_methods.append("")
+            except (TypeError, ValueError, OSError) as e:
+                log.warning(f"Could not extract method signature for {name}: {e}")
+                fallback_methods.append(f"    def {name}(self, *args, **kwargs):")
+                fallback_methods.append("        pass")
+                fallback_methods.append("")
+
+        fallback_code = f"""class {cls.__name__}:
+    def __init__(self, *args, **kwargs):
+        pass
+
+{chr(10).join(fallback_methods)}"""
+
+        return fallback_code
+
+
+def create_remote_class(
+    cls: Type,
+    resource_config: ServerlessResource,
+    dependencies: Optional[List[str]],
+    system_dependencies: Optional[List[str]],
+    extra: dict,
+):
+    """
+    Create a remote class wrapper.
+    """
+    # Validate inputs
+    if not inspect.isclass(cls):
+        raise TypeError(f"Expected a class, got {type(cls).__name__}")
+    if not hasattr(cls, "__name__"):
+        raise ValueError("Class must have a __name__ attribute")
+
+    class RemoteClassWrapper:
+        def __init__(self, *args, **kwargs):
+            self._class_type = cls
+            self._resource_config = resource_config
+            self._dependencies = dependencies or []
+            self._system_dependencies = system_dependencies or []
+            self._extra = extra
+            self._constructor_args = args
+            self._constructor_kwargs = kwargs
+            self._instance_id = f"{cls.__name__}_{uuid.uuid4().hex[:8]}"
+            self._initialized = False
+
+            self._clean_class_code = extract_class_code_simple(cls)
+
+            log.debug(f"Created remote class wrapper for {cls.__name__}")
+
+        async def _ensure_initialized(self):
+            """Ensure the remote instance is created."""
+            if self._initialized:
+                return
+
+            # Get remote resource
+            resource_manager = ResourceManager()
+            remote_resource = await resource_manager.get_or_deploy_resource(
+                self._resource_config
+            )
+            self._stub = stub_resource(remote_resource, **self._extra)
+
+            # Create the remote instance by calling a method (which will trigger instance creation)
+            # We'll do this on first method call
+            self._initialized = True
+
+        def __getattr__(self, name):
+            """Dynamically create method proxies for all class methods."""
+            if name.startswith("_"):
+                raise AttributeError(
+                    f"'{self.__class__.__name__}' object has no attribute '{name}'"
+                )
+
+            async def method_proxy(*args, **kwargs):
+                await self._ensure_initialized()
+
+                # Create class method request
+
+                # class_code = inspect.getsource(self._class_type)
+                class_code = self._clean_class_code
+
+                request = FunctionRequest(
+                    execution_type="class",
+                    class_name=self._class_type.__name__,
+                    class_code=class_code,
+                    method_name=name,
+                    args=[
+                        base64.b64encode(cloudpickle.dumps(arg)).decode("utf-8")
+                        for arg in args
+                    ],
+                    kwargs={
+                        k: base64.b64encode(cloudpickle.dumps(v)).decode("utf-8")
+                        for k, v in kwargs.items()
+                    },
+                    constructor_args=[
+                        base64.b64encode(cloudpickle.dumps(arg)).decode("utf-8")
+                        for arg in self._constructor_args
+                    ],
+                    constructor_kwargs={
+                        k: base64.b64encode(cloudpickle.dumps(v)).decode("utf-8")
+                        for k, v in self._constructor_kwargs.items()
+                    },
+                    dependencies=self._dependencies,
+                    system_dependencies=self._system_dependencies,
+                    instance_id=self._instance_id,
+                    create_new_instance=not hasattr(
+                        self, "_stub"
+                    ),  # Create new only on first call
+                )
+
+                # Execute via stub
+                return await self._stub.execute_class_method(request)  # type: ignore
+
+            return method_proxy
+
+    return RemoteClassWrapper

tetra_rp-0.8.0/src/tetra_rp/protos/remote_execution.py

@@ -0,0 +1,128 @@
+# TODO: generate using betterproto
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class FunctionRequest(BaseModel):
+    # MADE OPTIONAL - can be None for class-only execution
+    function_name: Optional[str] = Field(
+        default=None,
+        description="Name of the function to execute",
+    )
+    function_code: Optional[str] = Field(
+        default=None,
+        description="Source code of the function to execute",
+    )
+    args: List = Field(
+        default_factory=list,
+        description="List of base64-encoded cloudpickle-serialized arguments",
+    )
+    kwargs: Dict = Field(
+        default_factory=dict,
+        description="Dictionary of base64-encoded cloudpickle-serialized keyword arguments",
+    )
+    dependencies: Optional[List] = Field(
+        default=None,
+        description="Optional list of pip packages to install before executing the function",
+    )
+    system_dependencies: Optional[List] = Field(
+        default=None,
+        description="Optional list of system dependencies to install before executing the function",
+    )
+
+    # NEW FIELDS FOR CLASS SUPPORT
+    execution_type: str = Field(
+        default="function", description="Type of execution: 'function' or 'class'"
+    )
+    class_name: Optional[str] = Field(
+        default=None,
+        description="Name of the class to instantiate (for class execution)",
+    )
+    class_code: Optional[str] = Field(
+        default=None,
+        description="Source code of the class to instantiate (for class execution)",
+    )
+    constructor_args: Optional[List] = Field(
+        default_factory=list,
+        description="List of base64-encoded cloudpickle-serialized constructor arguments",
+    )
+    constructor_kwargs: Optional[Dict] = Field(
+        default_factory=dict,
+        description="Dictionary of base64-encoded cloudpickle-serialized constructor keyword arguments",
+    )
+    method_name: str = Field(
+        default="__call__",
+        description="Name of the method to call on the class instance",
+    )
+    instance_id: Optional[str] = Field(
+        default=None,
+        description="Unique identifier for the class instance (for persistence)",
+    )
+    create_new_instance: bool = Field(
+        default=True,
+        description="Whether to create a new instance or reuse existing one",
+    )
+
+    @model_validator(mode="after")
+    def validate_execution_requirements(self) -> "FunctionRequest":
+        """Validate that required fields are provided based on execution_type"""
+        if self.execution_type == "function":
+            if self.function_name is None:
+                raise ValueError(
+                    'function_name is required when execution_type is "function"'
+                )
+            if self.function_code is None:
+                raise ValueError(
+                    'function_code is required when execution_type is "function"'
+                )
+
+        elif self.execution_type == "class":
+            if self.class_name is None:
+                raise ValueError(
+                    'class_name is required when execution_type is "class"'
+                )
+            if self.class_code is None:
+                raise ValueError(
+                    'class_code is required when execution_type is "class"'
+                )
+
+        return self
+
+
+class FunctionResponse(BaseModel):
+    # EXISTING FIELDS (unchanged)
+    success: bool = Field(
+        description="Indicates if the function execution was successful",
+    )
+    result: Optional[str] = Field(
+        default=None,
+        description="Base64-encoded cloudpickle-serialized result of the function",
+    )
+    error: Optional[str] = Field(
+        default=None,
+        description="Error message if the function execution failed",
+    )
+    stdout: Optional[str] = Field(
+        default=None,
+        description="Captured standard output from the function execution",
+    )
+
+    # NEW FIELDS FOR CLASS SUPPORT
+    instance_id: Optional[str] = Field(
+        default=None, description="ID of the class instance that was used/created"
+    )
+    instance_info: Optional[Dict] = Field(
+        default=None,
+        description="Metadata about the class instance (creation time, call count, etc.)",
+    )
+
+
+class RemoteExecutorStub(ABC):
+    """Abstract base class for remote execution."""
+
+    @abstractmethod
+    async def ExecuteFunction(self, request: FunctionRequest) -> FunctionResponse:
+        """Execute a function on the remote resource."""
+        raise NotImplementedError("Subclasses should implement this method.")

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/src/tetra_rp/stubs/registry.py

@@ -1,13 +1,13 @@
 import logging
 from functools import singledispatch
-from .live_serverless import LiveServerlessStub
-from .serverless import ServerlessEndpointStub
+
 from ..core.resources import (
     CpuServerlessEndpoint,
     LiveServerless,
     ServerlessEndpoint,
 )
-
+from .live_serverless import LiveServerlessStub
+from .serverless import ServerlessEndpointStub
 
 log = logging.getLogger(__name__)
 
@@ -22,20 +22,29 @@ def stub_resource(resource, **extra):
 
 @stub_resource.register(LiveServerless)
 def _(resource, **extra):
+    stub = LiveServerlessStub(resource)
+
+    # Function execution
     async def stubbed_resource(
         func, dependencies, system_dependencies, *args, **kwargs
     ) -> dict:
         if args == (None,):
-            # cleanup: when the function is called with no args
             args = []
 
-        stub = LiveServerlessStub(resource)
         request = stub.prepare_request(
             func, dependencies, system_dependencies, *args, **kwargs
         )
         response = await stub.ExecuteFunction(request)
         return stub.handle_response(response)
 
+    # Class method execution
+    async def execute_class_method(request):
+        response = await stub.ExecuteFunction(request)
+        return stub.handle_response(response)
+
+    # Attach the method to the function
+    stubbed_resource.execute_class_method = execute_class_method
+
     return stubbed_resource
 
 

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/src/tetra_rp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tetra_rp
-Version: 0.6.0
+Version: 0.8.0
 Summary: A Python library for distributed inference and serving of machine learning models
 Author-email: Marut Pandya <pandyamarut@gmail.com>, Patrick Rachford <prachford@icloud.com>, Dean Quinanola <dean.quinanola@runpod.io>
 License: MIT

{tetra_rp-0.6.0 → tetra_rp-0.8.0}/src/tetra_rp.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 src/tetra_rp/__init__.py
 src/tetra_rp/client.py
+src/tetra_rp/execute_class.py
 src/tetra_rp/logger.py
 src/tetra_rp.egg-info/PKG-INFO
 src/tetra_rp.egg-info/SOURCES.txt

tetra_rp-0.6.0/src/tetra_rp/protos/remote_execution.py

@@ -1,57 +0,0 @@
-# TODO: generate using betterproto
-
-from abc import ABC, abstractmethod
-from typing import List, Dict, Optional
-from pydantic import BaseModel, Field
-
-
-class FunctionRequest(BaseModel):
-    function_name: str = Field(
-        description="Name of the function to execute",
-    )
-    function_code: str = Field(
-        description="Source code of the function to execute",
-    )
-    args: List = Field(
-        default_factory=list,
-        description="List of base64-encoded cloudpickle-serialized arguments",
-    )
-    kwargs: Dict = Field(
-        default_factory=dict,
-        description="Dictionary of base64-encoded cloudpickle-serialized keyword arguments",
-    )
-    dependencies: Optional[List] = Field(
-        default=None,
-        description="Optional list of pip packages to install before executing the function",
-    )
-    system_dependencies: Optional[List] = Field(
-        default=None,
-        description="Optional list of system dependencies to install before executing the function",
-    )
-
-
-class FunctionResponse(BaseModel):
-    success: bool = Field(
-        description="Indicates if the function execution was successful",
-    )
-    result: Optional[str] = Field(
-        default=None,
-        description="Base64-encoded cloudpickle-serialized result of the function",
-    )
-    error: Optional[str] = Field(
-        default=None,
-        description="Error message if the function execution failed",
-    )
-    stdout: Optional[str] = Field(
-        default=None,
-        description="Captured standard output from the function execution",
-    )
-
-
-class RemoteExecutorStub(ABC):
-    """Abstract base class for remote execution."""
-
-    @abstractmethod
-    async def ExecuteFunction(self, request: FunctionRequest) -> FunctionResponse:
-        """Execute a function on the remote resource."""
-        raise NotImplementedError("Subclasses should implement this method.")