kalibr 1.0.28__py3-none-any.whl → 1.1.3a0__py3-none-any.whl

kalibr/kalibr_app.py

@@ -1,343 +1,82 @@
-from fastapi import FastAPI, Request, UploadFile, File
-from fastapi.responses import JSONResponse, StreamingResponse as FastAPIStreamingResponse
-from typing import Callable, Dict, Any, List, Optional, get_type_hints
-import inspect
-import asyncio
-from datetime import datetime
-import uuid
-import os
+"""KalibrApp - Advanced app framework with async, file uploads, sessions"""
 
-from kalibr.types import FileUpload, Session, WorkflowState
+from typing import Callable, List, Optional
 
-class KalibrApp:
-    """
-    Enhanced app-level Kalibr framework with advanced capabilities:
-    - File upload handling
-    - Session management
-    - Streaming responses
-    - Complex workflows
-    - Multi-model schema generation
-    """
+import uvicorn
+from fastapi import FastAPI, File, UploadFile
+from fastapi.responses import StreamingResponse
+from kalibr.kalibr import Kalibr
+from kalibr.types import FileUpload, Session
 
-    def __init__(self, title="Kalibr Enhanced API", version="2.0.0", base_url: Optional[str] = None, models: Optional[List[str]] = None):
-        """
-        Initialize the Kalibr enhanced app.
-        Automatically determines correct base URL for deployed environments.
 
-        Priority:
-        1. Explicit `base_url` passed by user
-        2. Env var `KALIBR_BASE_URL`
-        3. Env var `FLY_APP_NAME` -> https://<fly_app_name>.fly.dev
-        4. Default localhost for dev
+class KalibrApp(Kalibr):
+    """Advanced Kalibr app with file uploads, sessions, and streaming"""
 
-        `models`: optional list like ["mcp"] or ["mcp","gpt-actions","gemini","copilot"]
-                  controls which schema endpoints are advertised.
-        """
-        self.app = FastAPI(title=title, version=version)
+    def __init__(self, title: str = "Kalibr API", version: str = "1.0.0"):
+        super().__init__(title=title, version=version)
+        self.sessions = {}  # In-memory session store
 
-        if base_url:
-            self.base_url = base_url
-        elif os.getenv("KALIBR_BASE_URL"):
-            self.base_url = os.getenv("KALIBR_BASE_URL")
-        elif os.getenv("FLY_APP_NAME"):
-            self.base_url = f"https://{os.getenv('FLY_APP_NAME')}.fly.dev"
-        else:
-            self.base_url = "http://localhost:8000"
+    def file_handler(self, name: str, allowed_extensions: List[str]):
+        """Decorator for file upload handlers"""
 
-        self.models_supported = models or ["mcp", "gpt-actions", "gemini", "copilot"]
-
-        # Storage for different action types
-        self.actions: Dict[str, Any] = {}
-        self.file_handlers: Dict[str, Any] = {}
-        self.session_actions: Dict[str, Any] = {}
-        self.stream_actions: Dict[str, Any] = {}
-        self.workflows: Dict[str, Any] = {}
-
-        # Session and workflow memory
-        self.sessions: Dict[str, Session] = {}
-        self.workflow_states: Dict[str, WorkflowState] = {}
-
-        self._setup_routes()
-
-    # -------------------------------------------------------------------------
-    # Action registration decorators
-    # -------------------------------------------------------------------------
-
-    def action(self, name: str, description: str = ""):
         def decorator(func: Callable):
-            self.actions[name] = {
-                "func": func,
-                "description": description,
-                "params": self._extract_params(func),
-            }
-
-            endpoint_path = f"/proxy/{name}"
-
-            async def endpoint_handler(request: Request):
-                params = {}
-                if request.method == "POST":
-                    try:
-                        body = await request.json()
-                        params = body if isinstance(body, dict) else {}
-                    except Exception:
-                        params = {}
-                else:
-                    params = dict(request.query_params)
-
-                try:
-                    result = func(**params)
-                    if inspect.isawaitable(result):
-                        result = await result
-                    return JSONResponse(content=result)
-                except Exception as e:
-                    return JSONResponse(content={"error": str(e)}, status_code=500)
-
-            self.app.post(endpoint_path)(endpoint_handler)
-            self.app.get(endpoint_path)(endpoint_handler)
-            return func
-
-        return decorator
-
-    def file_handler(self, name: str, allowed_extensions: List[str] = None, description: str = ""):
-        def decorator(func: Callable):
-            self.file_handlers[name] = {
-                "func": func,
-                "description": description,
-                "allowed_extensions": allowed_extensions or [],
-                "params": self._extract_params(func),
-            }
-
-            endpoint_path = f"/files/{name}"
-
+            @self.app.post(f"/proxy/{name}")
             async def file_endpoint(file: UploadFile = File(...)):
-                try:
-                    if allowed_extensions:
-                        file_ext = "." + file.filename.split(".")[-1] if "." in file.filename else ""
-                        if file_ext not in allowed_extensions:
-                            return JSONResponse(
-                                content={"error": f"File type {file_ext} not allowed. Allowed: {allowed_extensions}"},
-                                status_code=400,
-                            )
-
-                    content = await file.read()
-                    file_upload = FileUpload(
-                        filename=file.filename,
-                        content_type=file.content_type or "application/octet-stream",
-                        size=len(content),
-                        content=content,
-                    )
-
-                    result = func(file_upload)
-                    if inspect.isawaitable(result):
-                        result = await result
-                    return JSONResponse(content=result)
-                except Exception as e:
-                    return JSONResponse(content={"error": str(e)}, status_code=500)
+                # Validate file extension
+                if allowed_extensions:
+                    ext = f".{file.filename.split('.')[-1]}"
+                    if ext not in allowed_extensions:
+                        return {"error": f"File type not allowed. Allowed: {allowed_extensions}"}
+
+                # Create FileUpload object
+                content = await file.read()
+                file_obj = FileUpload(
+                    filename=file.filename,
+                    content_type=file.content_type,
+                    size=len(content),
+                    content=content,
+                )
+
+                # Call handler
+                result = await func(file_obj)
+                return result
 
-            self.app.post(endpoint_path)(file_endpoint)
             return func
 
         return decorator
 
     def session_action(self, name: str, description: str = ""):
-        def decorator(func: Callable):
-            self.session_actions[name] = {
-                "func": func,
-                "description": description,
-                "params": self._extract_params(func),
-            }
-
-            endpoint_path = f"/session/{name}"
-
-            async def session_endpoint(request: Request):
-                try:
-                    session_id = request.headers.get("X-Session-ID") or request.cookies.get("session_id")
-                    if not session_id or session_id not in self.sessions:
-                        session_id = str(uuid.uuid4())
-                        session = Session(session_id=session_id)
-                        self.sessions[session_id] = session
-                    else:
-                        session = self.sessions[session_id]
-                        session.last_accessed = datetime.now()
+        """Decorator for session-based actions"""
 
-                    body = await request.json() if request.method == "POST" else {}
-
-                    sig = inspect.signature(func)
-                    if "session" in sig.parameters:
-                        func_params = {k: v for k, v in body.items() if k != "session"}
-                        result = func(session=session, **func_params)
-                    else:
-                        result = func(**body)
+        def decorator(func: Callable):
+            @self.app.post(f"/proxy/{name}")
+            async def session_endpoint(session_id: str, **kwargs):
+                # Get or create session
+                if session_id not in self.sessions:
+                    self.sessions[session_id] = Session(session_id)
 
-                    if inspect.isawaitable(result):
-                        result = await result
+                session = self.sessions[session_id]
 
-                    response = JSONResponse(content=result)
-                    response.set_cookie("session_id", session_id)
-                    response.headers["X-Session-ID"] = session_id
-                    return response
-                except Exception as e:
-                    return JSONResponse(content={"error": str(e)}, status_code=500)
+                # Call handler
+                result = await func(session, **kwargs)
+                return result
 
-            self.app.post(endpoint_path)(session_endpoint)
             return func
 
         return decorator
 
-    def stream_action(self, name: str, description: str = ""):
-        def decorator(func: Callable):
-            self.stream_actions[name] = {
-                "func": func,
-                "description": description,
-                "params": self._extract_params(func),
-            }
-
-            endpoint_path = f"/stream/{name}"
-
-            async def stream_endpoint(request: Request):
-                try:
-                    params = dict(request.query_params) if request.method == "GET" else {}
-                    if request.method == "POST":
-                        body = await request.json()
-                        params.update(body)
+    def stream_action(self, name: str):
+        """Decorator for streaming responses"""
 
-                    sig = inspect.signature(func)
-                    type_hints = get_type_hints(func) if hasattr(func, "__annotations__") else {}
-                    converted_params = {}
-                    for key, value in params.items():
-                        if key in sig.parameters:
-                            param_type = type_hints.get(key, str)
-                            try:
-                                if param_type == int:
-                                    converted_params[key] = int(value)
-                                elif param_type == float:
-                                    converted_params[key] = float(value)
-                                elif param_type == bool:
-                                    converted_params[key] = value.lower() in ("true", "1", "yes")
-                                else:
-                                    converted_params[key] = value
-                            except Exception:
-                                converted_params[key] = value
-
-                    result = func(**converted_params)
-
-                    async def generate():
-                        import json
-                        if inspect.isasyncgen(result):
-                            async for item in result:
-                                yield json.dumps(item) + "\\n"
-                        elif inspect.isgenerator(result):
-                            for item in result:
-                                yield json.dumps(item) + "\\n"
+        def decorator(func: Callable):
+            @self.app.post(f"/proxy/{name}")
+            async def stream_endpoint(**kwargs):
+                async def generate():
+                    async for chunk in func(**kwargs):
+                        yield chunk
 
-                    return FastAPIStreamingResponse(generate(), media_type="application/x-ndjson")
-                except Exception as e:
-                    return JSONResponse(content={"error": str(e)}, status_code=500)
+                return StreamingResponse(generate(), media_type="text/event-stream")
 
-            self.app.get(endpoint_path)(stream_endpoint)
-            self.app.post(endpoint_path)(stream_endpoint)
             return func
 
         return decorator
-
-    # -------------------------------------------------------------------------
-    # Schema generation routes
-    # -------------------------------------------------------------------------
-
-    def _setup_routes(self):
-        from kalibr.schema_generators import (
-            OpenAPISchemaGenerator,
-            MCPSchemaGenerator,
-            GeminiSchemaGenerator,
-            CopilotSchemaGenerator,
-        )
-
-        openapi_gen = OpenAPISchemaGenerator()
-        mcp_gen = MCPSchemaGenerator()
-        gemini_gen = GeminiSchemaGenerator()
-        copilot_gen = CopilotSchemaGenerator()
-
-        @self.app.get("/")
-        def root():
-            schemas = {}
-            if "gpt-actions" in self.models_supported:
-                schemas["gpt_actions"] = f"{self.base_url}/gpt-actions.json"
-            schemas["claude_mcp"] = f"{self.base_url}/mcp.json"  # MCP is the default lingua franca
-            if "gemini" in self.models_supported:
-                schemas["gemini"] = f"{self.base_url}/schemas/gemini"
-            if "copilot" in self.models_supported:
-                schemas["copilot"] = f"{self.base_url}/schemas/copilot"
-
-            return {
-                "message": "Kalibr Enhanced API is running",
-                "actions": list(self.actions.keys()),
-                "schemas": schemas,
-            }
-
-        @self.app.get("/models/supported")
-        def supported_models():
-            return {"models": self.models_supported}
-
-        @self.app.get("/gpt-actions.json")
-        def gpt_actions_schema():
-            all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
-            return openapi_gen.generate_schema(all_actions, self.base_url)
-
-        @self.app.get("/mcp.json")
-        def mcp_manifest():
-            all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
-            return mcp_gen.generate_schema(all_actions, self.base_url)
-
-        @self.app.get("/schemas/gemini")
-        def gemini_schema():
-            all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
-            return gemini_gen.generate_schema(all_actions, self.base_url)
-
-        @self.app.get("/schemas/copilot")
-        def copilot_schema():
-            all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
-            return copilot_gen.generate_schema(all_actions, self.base_url)
-
-        @self.app.get("/health")
-        def health_check():
-            return {
-                "status": "healthy",
-                "service": "Kalibr Enhanced API",
-                "version": self.app.version,
-                "features": {
-                    "file_handlers": bool(self.file_handlers),
-                    "sessions": True,
-                    "streams": bool(self.stream_actions),
-                },
-            }
-
-    # -------------------------------------------------------------------------
-    # Helpers
-    # -------------------------------------------------------------------------
-
-    def _extract_params(self, func: Callable) -> Dict[str, Any]:
-        sig = inspect.signature(func)
-        params = {}
-        type_hints = get_type_hints(func) if hasattr(func, "__annotations__") else {}
-
-        for param_name, param in sig.parameters.items():
-            if param_name in ["session", "workflow_state", "file"]:
-                continue
-
-            param_type = "string"
-            anno = type_hints.get(param_name, param.annotation)
-            if anno == int:
-                param_type = "integer"
-            elif anno == bool:
-                param_type = "boolean"
-            elif anno == float:
-                param_type = "number"
-            elif anno == list:
-                param_type = "array"
-            elif anno == dict:
-                param_type = "object"
-
-            is_required = param.default == inspect.Parameter.empty
-            params[param_name] = {"type": param_type, "required": is_required}
-
-        return params

kalibr/middleware/__init__.py

@@ -0,0 +1,5 @@
+"""Kalibr Middleware Package"""
+
+from .auto_tracer import AutoTracerMiddleware
+
+__all__ = ["AutoTracerMiddleware"]