isa-model 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

isa_model/inference/backends/container_services.py

@@ -1,104 +0,0 @@
-"""
-Container Services Backend - Docker/K8s deployed services.
-Examples: Triton Inference Server, vLLM, TensorFlow Serving
-"""
-
-import aiohttp
-import json
-from typing import Dict, Any, List, Optional
-from .base_backend_client import BaseBackendClient
-from .triton_client import TritonBackendClient  # Re-export existing Triton client
-
-
-class VLLMBackendClient(BaseBackendClient):
-    """Pure connection client for vLLM service deployed in containers"""
-    
-    def __init__(self, base_url: str, api_key: Optional[str] = None):
-        self.base_url = base_url.rstrip('/')
-        self.api_key = api_key
-        self.headers = {"Content-Type": "application/json"}
-        if api_key:
-            self.headers["Authorization"] = f"Bearer {api_key}"
-        self._session = None
-    
-    async def _get_session(self):
-        """Get or create HTTP session"""
-        if self._session is None:
-            self._session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=60))
-        return self._session
-    
-    async def post(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """Make POST request to vLLM API"""
-        session = await self._get_session()
-        async with session.post(f"{self.base_url}{endpoint}", json=payload, headers=self.headers) as response:
-            response.raise_for_status()
-            return await response.json()
-    
-    async def get(self, endpoint: str) -> Dict[str, Any]:
-        """Make GET request to vLLM API"""
-        session = await self._get_session()
-        async with session.get(f"{self.base_url}{endpoint}", headers=self.headers) as response:
-            response.raise_for_status()
-            return await response.json()
-    
-    async def health_check(self) -> bool:
-        """Check if vLLM service is healthy"""
-        try:
-            await self.get("/health")
-            return True
-        except Exception:
-            return False
-            
-    async def close(self):
-        """Close the HTTP session"""
-        if self._session:
-            await self._session.close()
-            self._session = None
-
-
-class TensorFlowServingClient(BaseBackendClient):
-    """Backend client for TensorFlow Serving in containers"""
-    
-    def __init__(self, base_url: str, model_name: str, version: Optional[str] = None):
-        self.base_url = base_url.rstrip('/')
-        self.model_name = model_name
-        self.version = version or "latest"
-    
-    async def predict(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
-        """Make prediction using TensorFlow Serving"""
-        async with aiohttp.ClientSession() as session:
-            url = f"{self.base_url}/v1/models/{self.model_name}"
-            if self.version != "latest":
-                url += f"/versions/{self.version}"
-            url += ":predict"
-            
-            payload = {"instances": [inputs]}
-            async with session.post(url, json=payload) as response:
-                return await response.json()
-    
-    async def health_check(self) -> bool:
-        """Check if TensorFlow Serving is healthy"""
-        try:
-            async with aiohttp.ClientSession() as session:
-                url = f"{self.base_url}/v1/models/{self.model_name}"
-                async with session.get(url) as response:
-                    return response.status == 200
-        except Exception:
-            return False
-
-
-class KubernetesServiceClient(BaseBackendClient):
-    """Generic client for services deployed in Kubernetes"""
-    
-    def __init__(self, service_url: str, namespace: str = "default"):
-        self.service_url = service_url.rstrip('/')
-        self.namespace = namespace
-    
-    async def health_check(self) -> bool:
-        """Check if K8s service is healthy"""
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(f"{self.service_url}/health") as response:
-                    return response.status == 200
-        except Exception:
-            return False 

isa_model/inference/backends/local_services.py

@@ -1,72 +0,0 @@
-"""
-Local Services Backend - Services running locally on the same machine.
-Examples: Ollama, Local model servers
-"""
-
-import aiohttp
-import json
-from typing import Dict, Any, List, Optional
-from .base_backend_client import BaseBackendClient
-
-
-class OllamaBackendClient(BaseBackendClient):
-    """Pure connection client for local Ollama service"""
-    
-    def __init__(self, host: str = "localhost", port: int = 11434):
-        self.base_url = f"http://{host}:{port}"
-        self._session = None
-        
-    async def _get_session(self):
-        """Get or create HTTP session"""
-        if self._session is None:
-            self._session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=30))
-        return self._session
-        
-    async def post(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """Make POST request to Ollama API"""
-        session = await self._get_session()
-        async with session.post(f"{self.base_url}{endpoint}", json=payload) as response:
-            response.raise_for_status()
-            return await response.json()
-    
-    async def get(self, endpoint: str) -> Dict[str, Any]:
-        """Make GET request to Ollama API"""
-        session = await self._get_session()
-        async with session.get(f"{self.base_url}{endpoint}") as response:
-            response.raise_for_status()
-            return await response.json()
-    
-    async def health_check(self) -> bool:
-        """Check if Ollama service is healthy"""
-        try:
-            await self.get("/api/tags")
-            return True
-        except Exception:
-            return False
-            
-    async def close(self):
-        """Close the HTTP session"""
-        if self._session:
-            await self._session.close()
-            self._session = None
-
-
-class LocalModelServerClient(BaseBackendClient):
-    """Generic client for local model servers"""
-    
-    def __init__(self, base_url: str):
-        self.base_url = base_url.rstrip('/')
-        
-    async def generate_completion(self, model: str, prompt: str, **kwargs) -> Dict[str, Any]:
-        """Generate completion using generic local server"""
-        # Implementation depends on local server API
-        raise NotImplementedError("Implement based on your local server API")
-    
-    async def health_check(self) -> bool:
-        """Check if local server is healthy"""
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(f"{self.base_url}/health") as response:
-                    return response.status == 200
-        except Exception:
-            return False 

isa_model/inference/backends/openai_client.py

@@ -1,130 +0,0 @@
-import httpx
-import logging
-from typing import Dict, Any, Optional, AsyncGenerator
-import json
-import asyncio
-
-logger = logging.getLogger(__name__)
-
-class OpenAIBackendClient:
-    """Client for interacting with OpenAI API"""
-    
-    def __init__(self, api_key: str, api_base: str = "https://api.openai.com/v1", timeout: int = 60):
-        """
-        Initialize the OpenAI client
-        
-        Args:
-            api_key: OpenAI API key
-            api_base: Base URL for OpenAI API
-            timeout: Timeout for API calls in seconds
-        """
-        self.api_key = api_key
-        self.api_base = api_base
-        self.timeout = timeout
-        self.client = httpx.AsyncClient(timeout=timeout)
-        self._headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key}"
-        }
-        
-        logger.info(f"Initialized OpenAI client with API base: {api_base}")
-    
-    async def post(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Send a POST request to the OpenAI API
-        
-        Args:
-            endpoint: API endpoint (e.g., /chat/completions)
-            payload: Request payload
-            
-        Returns:
-            Response from the API
-        """
-        url = f"{self.api_base}{endpoint}"
-        try:
-            response = await self.client.post(url, json=payload, headers=self._headers)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as e:
-            error_detail = {}
-            try:
-                error_detail = e.response.json()
-            except Exception:
-                error_detail = {"status": e.response.status_code, "text": e.response.text}
-                
-            logger.error(f"OpenAI API error: {error_detail}")
-            raise ValueError(f"OpenAI API error: {error_detail}")
-        except Exception as e:
-            logger.error(f"Error communicating with OpenAI API: {e}")
-            raise
-    
-    async def stream_chat(self, payload: Dict[str, Any]) -> AsyncGenerator[str, None]:
-        """
-        Stream responses from the chat completion API
-        
-        Args:
-            payload: Request payload (must include 'stream': True)
-            
-        Yields:
-            Response chunks from the API
-        """
-        url = f"{self.api_base}/chat/completions"
-        payload["stream"] = True
-        
-        try:
-            async with self.client.stream("POST", url, json=payload, headers=self._headers) as response:
-                response.raise_for_status()
-                async for chunk in response.aiter_lines():
-                    if not chunk.strip():
-                        continue
-                    if chunk.startswith("data: "):
-                        chunk = chunk[6:]
-                    if chunk == "[DONE]":
-                        break
-                    try:
-                        content = json.loads(chunk)
-                        if content.get("choices") and len(content["choices"]) > 0:
-                            delta = content["choices"][0].get("delta", {})
-                            if "content" in delta:
-                                yield delta["content"]
-                    except json.JSONDecodeError:
-                        logger.warning(f"Failed to parse chunk: {chunk}")
-                        continue
-                    except Exception as e:
-                        logger.error(f"Error processing stream chunk: {e}")
-                        continue
-        except httpx.HTTPStatusError as e:
-            error_detail = {}
-            try:
-                error_detail = e.response.json()
-            except Exception:
-                error_detail = {"status": e.response.status_code, "text": e.response.text}
-                
-            logger.error(f"OpenAI API streaming error: {error_detail}")
-            raise ValueError(f"OpenAI API streaming error: {error_detail}")
-        except Exception as e:
-            logger.error(f"Error communicating with OpenAI API: {e}")
-            raise
-    
-    async def get_embedding(self, text: str, model: str = "text-embedding-3-small") -> list:
-        """
-        Get embedding for a text
-        
-        Args:
-            text: Text to embed
-            model: Embedding model to use
-            
-        Returns:
-            List of embedding values
-        """
-        payload = {
-            "input": text,
-            "model": model
-        }
-        
-        result = await self.post("/embeddings", payload)
-        return result["data"][0]["embedding"]
-    
-    async def close(self):
-        """Close the HTTP client"""
-        await self.client.aclose() 

isa_model/inference/backends/replicate_client.py

@@ -1,197 +0,0 @@
-import httpx
-import logging
-from typing import Dict, Any, Optional, AsyncGenerator, List
-import json
-import asyncio
-import time
-
-logger = logging.getLogger(__name__)
-
-class ReplicateBackendClient:
-    """Client for interacting with Replicate API"""
-    
-    def __init__(self, api_token: str, timeout: int = 120):
-        """
-        Initialize the Replicate client
-        
-        Args:
-            api_token: Replicate API token
-            timeout: Timeout for API calls in seconds
-        """
-        self.api_token = api_token
-        self.api_base = "https://api.replicate.com/v1"
-        self.timeout = timeout
-        self.client = httpx.AsyncClient(timeout=timeout)
-        self._headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Token {api_token}"
-        }
-        
-        logger.info(f"Initialized Replicate client")
-    
-    async def post(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Send a POST request to the Replicate API
-        
-        Args:
-            endpoint: API endpoint (e.g., /predictions)
-            payload: Request payload
-            
-        Returns:
-            Response from the API
-        """
-        url = f"{self.api_base}{endpoint}"
-        try:
-            response = await self.client.post(url, json=payload, headers=self._headers)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as e:
-            error_detail = {}
-            try:
-                error_detail = e.response.json()
-            except Exception:
-                error_detail = {"status": e.response.status_code, "text": e.response.text}
-                
-            logger.error(f"Replicate API error: {error_detail}")
-            raise ValueError(f"Replicate API error: {error_detail}")
-        except Exception as e:
-            logger.error(f"Error communicating with Replicate API: {e}")
-            raise
-    
-    async def get(self, endpoint: str) -> Dict[str, Any]:
-        """
-        Send a GET request to the Replicate API
-        
-        Args:
-            endpoint: API endpoint (e.g., /predictions/{id})
-            
-        Returns:
-            Response from the API
-        """
-        url = f"{self.api_base}{endpoint}"
-        try:
-            response = await self.client.get(url, headers=self._headers)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as e:
-            error_detail = {}
-            try:
-                error_detail = e.response.json()
-            except Exception:
-                error_detail = {"status": e.response.status_code, "text": e.response.text}
-                
-            logger.error(f"Replicate API error: {error_detail}")
-            raise ValueError(f"Replicate API error: {error_detail}")
-        except Exception as e:
-            logger.error(f"Error communicating with Replicate API: {e}")
-            raise
-    
-    async def create_prediction(self, model: str, version: str, input_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Create a prediction with Replicate
-        
-        Args:
-            model: Model identifier (e.g., "meta/llama-3-8b-instruct")
-            version: Model version or None to use latest
-            input_data: Input data for the model
-            
-        Returns:
-            Prediction result
-        """
-        model_identifier = f"{model}:{version}" if version else model
-        
-        payload = {
-            "version": model_identifier,
-            "input": input_data
-        }
-        
-        # Create prediction
-        prediction = await self.post("/predictions", payload)
-        prediction_id = prediction["id"]
-        
-        # Poll for completion
-        status = prediction["status"]
-        max_attempts = 120  # 10 minutes with 5 second intervals
-        attempts = 0
-        
-        while status in ["starting", "processing"] and attempts < max_attempts:
-            await asyncio.sleep(5)
-            prediction = await self.get(f"/predictions/{prediction_id}")
-            status = prediction["status"]
-            attempts += 1
-        
-        if status != "succeeded":
-            error = prediction.get("error", "Unknown error")
-            raise ValueError(f"Prediction failed: {error}")
-        
-        return prediction
-    
-    async def stream_prediction(self, model: str, version: str, input_data: Dict[str, Any]) -> AsyncGenerator[str, None]:
-        """
-        Stream a prediction from Replicate
-        
-        Args:
-            model: Model identifier (e.g., "meta/llama-3-8b-instruct")
-            version: Model version or None to use latest
-            input_data: Input data for the model
-            
-        Yields:
-            Output tokens from the model
-        """
-        # Set streaming in input data
-        input_data["stream"] = True
-        
-        model_identifier = f"{model}:{version}" if version else model
-        
-        payload = {
-            "version": model_identifier,
-            "input": input_data
-        }
-        
-        # Create prediction
-        prediction = await self.post("/predictions", payload)
-        prediction_id = prediction["id"]
-        
-        # Poll for the start of processing
-        status = prediction["status"]
-        while status in ["starting"]:
-            await asyncio.sleep(1)
-            prediction = await self.get(f"/predictions/{prediction_id}")
-            status = prediction["status"]
-        
-        # Stream the output
-        if status in ["processing", "succeeded"]:
-            current_outputs = []
-            last_output_len = 0
-            max_attempts = 180  # 15 minutes with 5 second intervals
-            attempts = 0
-            
-            while status in ["processing"] and attempts < max_attempts:
-                prediction = await self.get(f"/predictions/{prediction_id}")
-                status = prediction["status"]
-                
-                # Get outputs
-                outputs = prediction.get("output", [])
-                
-                # If we have new tokens, yield them
-                if isinstance(outputs, list) and len(outputs) > last_output_len:
-                    for i in range(last_output_len, len(outputs)):
-                        yield outputs[i]
-                    last_output_len = len(outputs)
-                
-                await asyncio.sleep(0.5)
-                attempts += 1
-            
-            # Final check for any remaining output
-            if status == "succeeded":
-                outputs = prediction.get("output", [])
-                if isinstance(outputs, list) and len(outputs) > last_output_len:
-                    for i in range(last_output_len, len(outputs)):
-                        yield outputs[i]
-        else:
-            error = prediction.get("error", "Unknown error")
-            raise ValueError(f"Prediction failed: {error}")
-    
-    async def close(self):
-        """Close the HTTP client"""
-        await self.client.aclose()