agnt5 0.1.3__cp39-abi3-win_amd64.whl

agnt5/runtimes/__init__.py

@@ -0,0 +1,13 @@
+"""
+Runtime adapters for different execution environments.
+"""
+
+from .base import RuntimeAdapter
+from .worker import WorkerRuntime
+from .asgi import ASGIRuntime
+
+__all__ = [
+    'RuntimeAdapter',
+    'WorkerRuntime', 
+    'ASGIRuntime',
+]

agnt5/runtimes/asgi.py

@@ -0,0 +1,270 @@
+"""
+ASGI runtime adapter for web framework integration.
+
+This adapter creates a pure ASGI application that can be run with any ASGI server
+like uvicorn, hypercorn, or daphne without requiring FastAPI or other frameworks.
+"""
+
+import json
+import logging
+import uuid
+from typing import Any, Dict, List, Tuple, Union
+from urllib.parse import parse_qs
+
+from .base import RuntimeAdapter, RuntimeContext, InvocationRequest, InvocationResponse
+from ..decorators import invoke_function, get_registered_functions
+
+logger = logging.getLogger(__name__)
+
+
+class ASGIRuntime(RuntimeAdapter):
+    """Pure ASGI runtime adapter."""
+    
+    def __init__(self, worker=None):
+        self.name = "asgi"
+        self.worker = worker
+        self._cors_enabled = True
+        self._cors_origins = ["*"]
+        
+    def enable_cors(self, origins: List[str] = None):
+        """Enable CORS with specified origins."""
+        self._cors_enabled = True
+        self._cors_origins = origins or ["*"]
+        
+    def disable_cors(self):
+        """Disable CORS."""
+        self._cors_enabled = False
+        
+    async def __call__(self, scope: dict, receive, send):
+        """ASGI application entry point."""
+        assert scope['type'] == 'http'
+        
+        # Parse request
+        method = scope['method']
+        path = scope['path']
+        
+        # Handle CORS preflight
+        if method == 'OPTIONS' and self._cors_enabled:
+            await self._handle_cors_preflight(scope, receive, send)
+            return
+            
+        # Route to appropriate handler
+        if path.startswith('/invoke/'):
+            await self._handle_invocation(scope, receive, send)
+        elif path == '/health':
+            await self._handle_health(scope, receive, send)
+        elif path == '/functions':
+            await self._handle_list_functions(scope, receive, send)
+        else:
+            await self._handle_not_found(scope, receive, send)
+            
+    async def _handle_invocation(self, scope: dict, receive, send):
+        """Handle function invocation requests."""
+        path = scope['path']
+        method = scope['method']
+        
+        if method != 'POST':
+            await self._send_error(send, 405, "Method not allowed")
+            return
+            
+        # Extract function name from path: /invoke/{function_name}
+        path_parts = path.split('/')
+        if len(path_parts) < 3:
+            await self._send_error(send, 400, "Invalid path format")
+            return
+            
+        function_name = path_parts[2]
+        
+        try:
+            # Read request body
+            body = b''
+            while True:
+                message = await receive()
+                if message['type'] == 'http.request':
+                    body += message.get('body', b'')
+                    if not message.get('more_body', False):
+                        break
+                        
+            # Parse JSON body
+            try:
+                if body:
+                    input_data = json.loads(body.decode('utf-8'))
+                    input_bytes = json.dumps(input_data).encode('utf-8')
+                else:
+                    input_bytes = b'{}'
+            except (json.JSONDecodeError, UnicodeDecodeError) as e:
+                await self._send_error(send, 400, f"Invalid JSON: {str(e)}")
+                return
+                
+            # Create invocation request
+            invocation_id = str(uuid.uuid4())
+            request = InvocationRequest(
+                invocation_id=invocation_id,
+                service_name=self.worker.service_name if self.worker else "unknown",
+                handler_name=function_name,
+                input_data=input_bytes
+            )
+            
+            # Create runtime context
+            ctx = RuntimeContext(
+                invocation_id=invocation_id,
+                service_name=request.service_name,
+                component_name=function_name
+            )
+            
+            # Handle the request
+            response = await self.handle_request(ctx, request)
+            
+            if response.success:
+                # Parse output data back to JSON for HTTP response
+                try:
+                    if response.output_data:
+                        output = json.loads(response.output_data.decode('utf-8'))
+                    else:
+                        output = None
+                        
+                    await self._send_json_response(send, 200, {
+                        "result": output,
+                        "invocation_id": response.invocation_id
+                    })
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    # If output is not JSON, send as raw bytes (base64 encoded)
+                    import base64
+                    await self._send_json_response(send, 200, {
+                        "result": base64.b64encode(response.output_data).decode('utf-8'),
+                        "invocation_id": response.invocation_id,
+                        "encoding": "base64"
+                    })
+            else:
+                await self._send_error(send, 500, response.error_message or "Function execution failed")
+                
+        except Exception as e:
+            logger.exception(f"Error handling invocation for {function_name}")
+            await self._send_error(send, 500, f"Internal server error: {str(e)}")
+            
+    async def _handle_health(self, scope: dict, receive, send):
+        """Handle health check requests."""
+        await self._send_json_response(send, 200, {
+            "status": "healthy",
+            "runtime": self.name,
+            "service": self.worker.service_name if self.worker else "unknown"
+        })
+        
+    async def _handle_list_functions(self, scope: dict, receive, send):
+        """Handle function listing requests."""
+        functions = get_registered_functions()
+        function_info = []
+        
+        for name, func in functions.items():
+            info = {
+                "name": name,
+                "type": "function"
+            }
+            if hasattr(func, '__doc__') and func.__doc__:
+                info["description"] = func.__doc__.strip()
+            function_info.append(info)
+            
+        await self._send_json_response(send, 200, {
+            "functions": function_info,
+            "count": len(function_info)
+        })
+        
+    async def _handle_not_found(self, scope: dict, receive, send):
+        """Handle 404 responses."""
+        await self._send_error(send, 404, "Not found")
+        
+    async def _handle_cors_preflight(self, scope: dict, receive, send):
+        """Handle CORS preflight requests."""
+        headers = [
+            (b'access-control-allow-origin', b'*'),
+            (b'access-control-allow-methods', b'GET, POST, OPTIONS'),
+            (b'access-control-allow-headers', b'content-type'),
+            (b'access-control-max-age', b'3600'),
+        ]
+        
+        await send({
+            'type': 'http.response.start',
+            'status': 200,
+            'headers': headers
+        })
+        await send({
+            'type': 'http.response.body',
+            'body': b''
+        })
+        
+    async def _send_json_response(self, send, status: int, data: dict):
+        """Send JSON response with optional CORS headers."""
+        headers = [(b'content-type', b'application/json')]
+        
+        if self._cors_enabled:
+            headers.extend([
+                (b'access-control-allow-origin', b'*'),
+                (b'access-control-allow-methods', b'GET, POST, OPTIONS'),
+                (b'access-control-allow-headers', b'content-type'),
+            ])
+            
+        body = json.dumps(data).encode('utf-8')
+        
+        await send({
+            'type': 'http.response.start',
+            'status': status,
+            'headers': headers
+        })
+        await send({
+            'type': 'http.response.body',
+            'body': body
+        })
+        
+    async def _send_error(self, send, status: int, message: str):
+        """Send error response."""
+        await self._send_json_response(send, status, {
+            "error": message,
+            "status": status
+        })
+        
+    async def handle_request(
+        self, 
+        ctx: RuntimeContext, 
+        request: InvocationRequest
+    ) -> InvocationResponse:
+        """
+        Handle function invocation using the decorator system.
+        """
+        logger.info(f"Handling ASGI invocation: {request.handler_name}")
+        
+        try:
+            # Create context dict for the function
+            function_context = {
+                'invocation_id': ctx.invocation_id,
+                'service_name': ctx.service_name,
+                'handler_name': request.handler_name,
+                'tenant_id': ctx.tenant_id,
+                'deployment_id': ctx.deployment_id,
+                'metadata': {**ctx.metadata, **request.metadata}
+            }
+            
+            # Call the function through the decorator system
+            result_data = invoke_function(
+                handler_name=request.handler_name,
+                input_data=request.input_data, 
+                context=function_context
+            )
+            
+            logger.info(f"ASGI invocation {request.handler_name} completed successfully")
+            
+            return InvocationResponse(
+                invocation_id=request.invocation_id,
+                output_data=result_data,
+                success=True
+            )
+            
+        except Exception as e:
+            error_msg = f"Function {request.handler_name} failed: {str(e)}"
+            logger.error(error_msg)
+            
+            return InvocationResponse(
+                invocation_id=request.invocation_id,
+                output_data=b'',
+                success=False,
+                error_message=error_msg
+            )

agnt5/runtimes/base.py

@@ -0,0 +1,78 @@
+"""
+Base runtime adapter class.
+"""
+
+from typing import Any, Dict, Optional, Protocol
+
+
+class InvocationRequest:
+    """Request for function invocation."""
+    
+    def __init__(
+        self, 
+        invocation_id: str,
+        service_name: str,
+        handler_name: str,
+        input_data: bytes,
+        metadata: Optional[Dict[str, str]] = None
+    ):
+        self.invocation_id = invocation_id
+        self.service_name = service_name
+        self.handler_name = handler_name
+        self.input_data = input_data
+        self.metadata = metadata or {}
+
+
+class InvocationResponse:
+    """Response from function invocation."""
+    
+    def __init__(
+        self,
+        invocation_id: str,
+        output_data: bytes,
+        success: bool = True,
+        error_message: Optional[str] = None,
+        metadata: Optional[Dict[str, str]] = None
+    ):
+        self.invocation_id = invocation_id
+        self.output_data = output_data
+        self.success = success
+        self.error_message = error_message
+        self.metadata = metadata or {}
+
+
+class RuntimeContext:
+    """Runtime execution context."""
+    
+    def __init__(
+        self,
+        invocation_id: str,
+        service_name: str,
+        component_name: str,
+        tenant_id: str = "default",
+        deployment_id: str = "default",
+        metadata: Optional[Dict[str, str]] = None
+    ):
+        self.invocation_id = invocation_id
+        self.service_name = service_name
+        self.component_name = component_name
+        self.tenant_id = tenant_id
+        self.deployment_id = deployment_id
+        self.metadata = metadata or {}
+
+
+class RuntimeAdapter(Protocol):
+    """Protocol for runtime adapters.
+    
+    Any class implementing this protocol can be used as a RuntimeAdapter.
+    The Protocol pattern uses duck typing - if an object has the required
+    methods with the correct signature, it satisfies the protocol.
+    """
+    
+    async def handle_request(
+        self, 
+        ctx: RuntimeContext, 
+        request: InvocationRequest
+    ) -> InvocationResponse:
+        """Handle a function invocation request."""
+        ...

agnt5/runtimes/worker.py

@@ -0,0 +1,77 @@
+"""
+Standalone runtime adapter for direct worker execution.
+
+This adapter is used when running workers directly with asyncio.run(main()).
+"""
+
+import json
+import logging
+import uuid
+from typing import Any, Dict
+
+from .base import RuntimeAdapter, RuntimeContext, InvocationRequest, InvocationResponse
+from ..decorators import invoke_function
+
+logger = logging.getLogger(__name__)
+
+
+class WorkerRuntime(RuntimeAdapter):
+    """Runtime adapter for standalone worker execution."""
+    
+    def __init__(self):
+        self.name = "standalone"
+        
+    async def handle_request(
+        self, 
+        ctx: RuntimeContext, 
+        request: InvocationRequest
+    ) -> InvocationResponse:
+        """
+        Handle function invocation by directly calling the decorated function.
+        
+        Args:
+            ctx: Runtime execution context
+            request: Invocation request with handler name and input data
+            
+        Returns:
+            InvocationResponse with function result or error
+        """
+        logger.info(f"Handling standalone invocation: {request.handler_name}")
+        
+        try:
+            # Create context dict for the function
+            function_context = {
+                'invocation_id': ctx.invocation_id,
+                'service_name': ctx.service_name,
+                'handler_name': request.handler_name,
+                'tenant_id': ctx.tenant_id,
+                'deployment_id': ctx.deployment_id,
+                'metadata': {**ctx.metadata, **request.metadata}
+            }
+            
+            # Call the function through the decorator system
+            result_data = invoke_function(
+                handler_name=request.handler_name,
+                input_data=request.input_data, 
+                context=function_context
+            )
+            
+            logger.info(f"Standalone invocation {request.handler_name} completed successfully")
+            
+            return InvocationResponse(
+                invocation_id=request.invocation_id,
+                output_data=result_data,
+                success=True
+            )
+            
+        except Exception as e:
+            error_msg = f"Function {request.handler_name} failed: {str(e)}"
+            logger.error(error_msg)
+            
+            # Return error response with empty output
+            return InvocationResponse(
+                invocation_id=request.invocation_id,
+                output_data=b'',
+                success=False,
+                error_message=error_msg
+            )

agnt5/version.py

@@ -0,0 +1,23 @@
+
+
+# Read version from pyproject.toml to maintain single source of truth
+def _get_version():
+    try:
+        import tomllib
+    except ImportError:
+        # Python < 3.11 fallback
+        try:
+            import tomli as tomllib
+        except ImportError:
+            # Final fallback if no toml library available
+            return "UNKNOWN"
+    
+    try:
+        import pathlib
+        pyproject_path = pathlib.Path(__file__).parent.parent.parent / "pyproject.toml"
+        with open(pyproject_path, "rb") as f:
+            pyproject_data = tomllib.load(f)
+        return pyproject_data["project"]["version"]
+    except Exception:
+        # Fallback version if reading fails
+        return "UNKNOWN"