isa-model 0.3.91__py3-none-any.whl → 0.4.3__py3-none-any.whl

isa_model/inference/adapter/unified_api.py

@@ -1,248 +0,0 @@
-import os
-import json
-import logging
-from typing import Dict, List, Any, Optional, Union
-from fastapi import FastAPI, HTTPException, Depends, Request
-from pydantic import BaseModel, Field
-
-from isa_model.inference.ai_factory import AIFactory
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("unified_api")
-
-# Create FastAPI app
-app = FastAPI(
-    title="Unified AI Model API",
-    description="API for inference with Llama3-8B, Gemma3-4B, Whisper, and BGE-M3 models",
-    version="1.0.0"
-)
-
-# Models
-class ChatMessage(BaseModel):
-    role: str = Field(..., description="Role of the message sender (system, user, assistant)")
-    content: str = Field(..., description="Content of the message")
-
-class ChatCompletionRequest(BaseModel):
-    model: str = Field(..., description="Model ID to use (llama, gemma)")
-    messages: List[ChatMessage] = Field(..., description="List of messages in the conversation")
-    temperature: Optional[float] = Field(0.7, description="Sampling temperature")
-    max_tokens: Optional[int] = Field(512, description="Maximum number of tokens to generate")
-    top_p: Optional[float] = Field(0.9, description="Top-p sampling parameter")
-    top_k: Optional[int] = Field(50, description="Top-k sampling parameter")
-
-class ChatCompletionResponse(BaseModel):
-    model: str = Field(..., description="Model used for completion")
-    choices: List[Dict[str, Any]] = Field(..., description="Generated completions")
-    usage: Dict[str, int] = Field(..., description="Token usage statistics")
-
-class EmbeddingRequest(BaseModel):
-    model: str = Field(..., description="Model ID to use (bge_embed)")
-    input: Union[str, List[str]] = Field(..., description="Text to embed")
-    normalize: Optional[bool] = Field(True, description="Whether to normalize embeddings")
-
-class TranscriptionRequest(BaseModel):
-    model: str = Field(..., description="Model ID to use (whisper)")
-    audio: str = Field(..., description="Base64-encoded audio data or URL")
-    language: Optional[str] = Field("en", description="Language code")
-
-# Factory for creating services
-ai_factory = AIFactory()
-
-# Dependency to get LLM service
-async def get_llm_service(model: str):
-    if model == "llama":
-        return await ai_factory.get_llm_service("llama")
-    elif model == "gemma":
-        return await ai_factory.get_llm_service("gemma")
-    else:
-        raise HTTPException(status_code=400, detail=f"Unsupported model: {model}")
-
-# Dependency to get embedding service
-async def get_embedding_service(model: str):
-    if model == "bge_embed":
-        return await ai_factory.get_embedding_service("bge_embed")
-    else:
-        raise HTTPException(status_code=400, detail=f"Unsupported model: {model}")
-
-# Dependency to get speech service
-async def get_speech_service(model: str):
-    if model == "whisper":
-        return await ai_factory.get_speech_service("whisper")
-    else:
-        raise HTTPException(status_code=400, detail=f"Unsupported model: {model}")
-
-# Endpoints
-@app.post("/v1/chat/completions", response_model=ChatCompletionResponse)
-async def chat_completion(request: ChatCompletionRequest):
-    """Generate chat completion"""
-    try:
-        # Get the appropriate service
-        service = await get_llm_service(request.model)
-        
-        # Format messages
-        formatted_messages = [{"role": msg.role, "content": msg.content} for msg in request.messages]
-        
-        # Extract system prompt if present
-        system_prompt = None
-        if formatted_messages and formatted_messages[0]["role"] == "system":
-            system_prompt = formatted_messages[0]["content"]
-            formatted_messages = formatted_messages[1:]
-        
-        # Get user prompt (last user message)
-        user_prompt = ""
-        for msg in reversed(formatted_messages):
-            if msg["role"] == "user":
-                user_prompt = msg["content"]
-                break
-        
-        if not user_prompt:
-            raise HTTPException(status_code=400, detail="No user message found")
-        
-        # Set generation config
-        generation_config = {
-            "temperature": request.temperature,
-            "max_new_tokens": request.max_tokens,
-            "top_p": request.top_p,
-            "top_k": request.top_k
-        }
-        
-        # Generate completion
-        completion = await service.generate(
-            prompt=user_prompt,
-            system_prompt=system_prompt,
-            generation_config=generation_config
-        )
-        
-        # Format response
-        response = {
-            "model": request.model,
-            "choices": [
-                {
-                    "message": {
-                        "role": "assistant",
-                        "content": completion
-                    },
-                    "finish_reason": "stop",
-                    "index": 0
-                }
-            ],
-            "usage": {
-                "prompt_tokens": len(user_prompt.split()),
-                "completion_tokens": len(completion.split()),
-                "total_tokens": len(user_prompt.split()) + len(completion.split())
-            }
-        }
-        
-        return response
-        
-    except Exception as e:
-        logger.error(f"Error in chat completion: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/v1/embeddings")
-async def create_embedding(request: EmbeddingRequest):
-    """Generate embeddings for text"""
-    try:
-        # Get the embedding service
-        service = await get_embedding_service("bge_embed")
-        
-        # Generate embeddings
-        if isinstance(request.input, str):
-            embeddings = await service.embed(request.input, normalize=request.normalize)
-            data = [{"embedding": embeddings[0].tolist(), "index": 0}]
-        else:
-            embeddings = await service.embed(request.input, normalize=request.normalize)
-            data = [{"embedding": emb.tolist(), "index": i} for i, emb in enumerate(embeddings)]
-        
-        # Format response
-        response = {
-            "model": request.model,
-            "data": data,
-            "usage": {
-                "prompt_tokens": sum(len(text.split()) for text in (request.input if isinstance(request.input, list) else [request.input])),
-                "total_tokens": sum(len(text.split()) for text in (request.input if isinstance(request.input, list) else [request.input]))
-            }
-        }
-        
-        return response
-        
-    except Exception as e:
-        logger.error(f"Error in embedding generation: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/v1/audio/transcriptions")
-async def transcribe_audio(request: TranscriptionRequest):
-    """Transcribe audio to text"""
-    try:
-        import base64
-        
-        # Get the speech service
-        service = await get_speech_service("whisper")
-        
-        # Process audio
-        if request.audio.startswith(("http://", "https://")):
-            # URL - download audio
-            import requests
-            audio_data = requests.get(request.audio).content
-        else:
-            # Base64 - decode
-            audio_data = base64.b64decode(request.audio)
-        
-        # Transcribe
-        transcription = await service.transcribe(
-            audio=audio_data, 
-            language=request.language
-        )
-        
-        # Format response
-        response = {
-            "model": request.model,
-            "text": transcription
-        }
-        
-        return response
-        
-    except Exception as e:
-        logger.error(f"Error in audio transcription: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-# Health check endpoint
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy"}
-
-# Model info endpoint
-@app.get("/v1/models")
-async def list_models():
-    """List available models"""
-    models = [
-        {
-            "id": "llama",
-            "type": "llm",
-            "description": "Llama3-8B language model"
-        },
-        {
-            "id": "gemma",
-            "type": "llm",
-            "description": "Gemma3-4B language model"
-        },
-        {
-            "id": "whisper",
-            "type": "speech",
-            "description": "Whisper-tiny speech-to-text model"
-        },
-        {
-            "id": "bge_embed",
-            "type": "embedding",
-            "description": "BGE-M3 text embedding model"
-        }
-    ]
-    
-    return {"data": models}
-
-# Main entry point
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8080) 

isa_model/inference/services/helpers/stacked_config.py

@@ -1,148 +0,0 @@
-"""
-Configuration system for stacked services
-"""
-
-from typing import Dict, Any, List, Optional
-from dataclasses import dataclass, field
-from enum import Enum
-
-# Define stacked service specific layer types
-class StackedLayerType(Enum):
-    """Types of processing layers for stacked services"""
-    INTELLIGENCE = "intelligence"      # High-level understanding
-    DETECTION = "detection"           # Element/object detection  
-    CLASSIFICATION = "classification" # Detailed classification
-    VALIDATION = "validation"         # Result validation
-    TRANSFORMATION = "transformation" # Data transformation
-    GENERATION = "generation"         # Content generation
-    ENHANCEMENT = "enhancement"       # Quality enhancement
-    CONTROL = "control"              # Precise control/refinement
-    UPSCALING = "upscaling"          # Resolution enhancement
-
-@dataclass
-class LayerConfig:
-    """Configuration for a processing layer"""
-    name: str
-    layer_type: StackedLayerType
-    service_type: str                  # e.g., 'vision', 'llm'
-    model_name: str
-    parameters: Dict[str, Any]
-    depends_on: List[str]             # Layer dependencies
-    timeout: float = 30.0
-    retry_count: int = 1
-    fallback_enabled: bool = True
-
-@dataclass
-class LayerResult:
-    """Result from a processing layer"""
-    layer_name: str
-    success: bool
-    data: Any
-    metadata: Dict[str, Any]
-    execution_time: float
-    error: Optional[str] = None
-
-class WorkflowType(Enum):
-    """Predefined workflow types"""
-    UI_ANALYSIS_FAST = "ui_analysis_fast"
-    UI_ANALYSIS_ACCURATE = "ui_analysis_accurate"
-    UI_ANALYSIS_COMPREHENSIVE = "ui_analysis_comprehensive"
-    SEARCH_PAGE_ANALYSIS = "search_page_analysis"
-    CONTENT_EXTRACTION = "content_extraction"
-    FORM_INTERACTION = "form_interaction"
-    NAVIGATION_ANALYSIS = "navigation_analysis"
-    CUSTOM = "custom"
-
-@dataclass
-class StackedServiceConfig:
-    """Configuration for a stacked service workflow"""
-    name: str
-    workflow_type: WorkflowType
-    layers: List[LayerConfig] = field(default_factory=list)
-    global_timeout: float = 120.0
-    parallel_execution: bool = False
-    fail_fast: bool = False
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-class ConfigManager:
-    """Manager for stacked service configurations"""
-    
-    PREDEFINED_CONFIGS = {
-        WorkflowType.UI_ANALYSIS_FAST: {
-            "name": "Fast UI Analysis",
-            "layers": [
-                LayerConfig(
-                    name="page_intelligence",
-                    layer_type=StackedLayerType.INTELLIGENCE,
-                    service_type="vision",
-                    model_name="gpt-4.1-nano",
-                    parameters={"max_tokens": 300},
-                    depends_on=[],
-                    timeout=10.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="element_detection",
-                    layer_type=StackedLayerType.DETECTION,
-                    service_type="vision",
-                    model_name="omniparser",
-                    parameters={
-                        "imgsz": 480,
-                        "box_threshold": 0.08,
-                        "iou_threshold": 0.2
-                    },
-                    depends_on=["page_intelligence"],
-                    timeout=15.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="element_classification",
-                    layer_type=StackedLayerType.CLASSIFICATION,
-                    service_type="vision",
-                    model_name="gpt-4.1-nano",
-                    parameters={"max_tokens": 200},
-                    depends_on=["page_intelligence", "element_detection"],
-                    timeout=20.0,
-                    fallback_enabled=False
-                )
-            ],
-            "global_timeout": 60.0,
-            "parallel_execution": False,
-            "fail_fast": False,
-            "metadata": {
-                "description": "Fast UI analysis optimized for speed",
-                "expected_time": "30-45 seconds",
-                "accuracy": "medium"
-            }
-        }
-    }
-    
-    @classmethod
-    def get_config(cls, workflow_type: WorkflowType) -> StackedServiceConfig:
-        """Get predefined configuration for a workflow type"""
-        if workflow_type not in cls.PREDEFINED_CONFIGS:
-            raise ValueError(f"Unknown workflow type: {workflow_type}")
-        
-        config_data = cls.PREDEFINED_CONFIGS[workflow_type]
-        
-        return StackedServiceConfig(
-            name=config_data["name"],
-            workflow_type=workflow_type,
-            layers=config_data["layers"],
-            global_timeout=config_data["global_timeout"],
-            parallel_execution=config_data["parallel_execution"],
-            fail_fast=config_data["fail_fast"],
-            metadata=config_data["metadata"]
-        )
-
-# Convenience function for quick access
-def get_ui_analysis_config(speed: str = "accurate") -> StackedServiceConfig:
-    """Get UI analysis configuration by speed preference"""
-    speed_mapping = {
-        "fast": WorkflowType.UI_ANALYSIS_FAST,
-        "accurate": WorkflowType.UI_ANALYSIS_ACCURATE,
-        "comprehensive": WorkflowType.UI_ANALYSIS_COMPREHENSIVE
-    }
-    
-    workflow_type = speed_mapping.get(speed.lower(), WorkflowType.UI_ANALYSIS_ACCURATE)
-    return ConfigManager.get_config(workflow_type)