indoxrouter 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

indoxRouter/providers/google.py

@@ -1,216 +0,0 @@
-import json
-import os
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-
-import google.generativeai as genai
-from google.generativeai.types import HarmCategory, HarmBlockThreshold
-
-from .base_provider import BaseProvider
-from ..utils.exceptions import ModelNotFoundError, ProviderAPIError, RateLimitError
-
-
-class Provider(BaseProvider):
-    """
-    Google Gemini provider implementation
-    """
-
-    def __init__(self, api_key: str, model_name: str):
-        """
-        Initialize the Google provider
-
-        Args:
-            api_key: Google API key
-            model_name: Model name (e.g., gemini-1.5-pro)
-        """
-        super().__init__(api_key, model_name)
-
-        # Configure the Google API client
-        genai.configure(api_key=api_key)
-
-        # Load model configuration
-        self.model_config = self._load_model_config(model_name)
-
-        # Set default generation config
-        self.generation_config = {
-            "temperature": 0.7,
-            "top_p": 0.95,
-            "top_k": 40,
-            "max_output_tokens": 8192,
-        }
-
-        # Set default safety settings (moderate filtering)
-        self.safety_settings = {
-            HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-            HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-            HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-            HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-        }
-
-    def _load_model_config(self, model_name: str) -> Dict[str, Any]:
-        """
-        Load model configuration from the JSON file
-
-        Args:
-            model_name: Model name to load configuration for
-
-        Returns:
-            Model configuration dictionary
-
-        Raises:
-            ModelNotFoundError: If the model is not found in the configuration
-        """
-        config_path = Path(__file__).parent / "google.json"
-
-        try:
-            with open(config_path, "r") as f:
-                models = json.load(f)
-
-            for model in models:
-                if model.get("modelName") == model_name:
-                    return model
-
-            raise ModelNotFoundError(f"Model {model_name} not found in Google provider")
-
-        except FileNotFoundError:
-            raise ModelNotFoundError(f"Google provider configuration file not found")
-        except json.JSONDecodeError:
-            raise ModelNotFoundError(
-                f"Invalid JSON in Google provider configuration file"
-            )
-
-    def estimate_cost(self, prompt: str, max_tokens: int) -> float:
-        """
-        Estimate the cost of generating a completion
-
-        Args:
-            prompt: Prompt text
-            max_tokens: Maximum number of tokens to generate
-
-        Returns:
-            Estimated cost in USD
-        """
-        # Count tokens in the prompt
-        prompt_tokens = self.count_tokens(prompt)
-
-        # Calculate cost based on input and output pricing
-        input_cost = (prompt_tokens / 1000) * self.model_config.get(
-            "inputPricePer1KTokens", 0
-        )
-        output_cost = (max_tokens / 1000) * self.model_config.get(
-            "outputPricePer1KTokens", 0
-        )
-
-        return input_cost + output_cost
-
-    def count_tokens(self, text: str) -> int:
-        """
-        Count the number of tokens in a text
-
-        Args:
-            text: Text to count tokens for
-
-        Returns:
-            Number of tokens
-        """
-        try:
-            # Use Google's tokenizer if available
-            model = genai.GenerativeModel(self.model_name)
-            return model.count_tokens(text).total_tokens
-        except Exception:
-            # Fallback to approximate token counting
-            return len(text.split())
-
-    def generate(self, prompt: str, **kwargs) -> Dict[str, Any]:
-        """
-        Generate a completion for the given prompt
-
-        Args:
-            prompt: Prompt text
-            **kwargs: Additional parameters for the generation
-
-        Returns:
-            Dictionary containing the generated text, cost, and usage statistics
-
-        Raises:
-            ProviderAPIError: If there's an error with the provider API
-            RateLimitError: If the provider's rate limit is exceeded
-        """
-        try:
-            # Get generation parameters
-            max_tokens = kwargs.get("max_tokens", 1024)
-            temperature = kwargs.get("temperature", 0.7)
-            top_p = kwargs.get("top_p", 0.95)
-            top_k = kwargs.get("top_k", 40)
-
-            # Update generation config
-            generation_config = {
-                "temperature": temperature,
-                "top_p": top_p,
-                "top_k": top_k,
-                "max_output_tokens": max_tokens,
-            }
-
-            # Prepare system prompt if provided
-            system_prompt = kwargs.get(
-                "system_prompt", self.model_config.get("systemPrompt", "")
-            )
-
-            # Create the model
-            model = genai.GenerativeModel(
-                model_name=self.model_name,
-                generation_config=generation_config,
-                safety_settings=self.safety_settings,
-            )
-
-            # Format the prompt using the template if available
-            prompt_template = self.model_config.get("promptTemplate", "")
-            if prompt_template and "%1" in prompt_template:
-                formatted_prompt = prompt_template.replace("%1", prompt)
-            else:
-                formatted_prompt = prompt
-
-            # Generate the completion
-            if system_prompt:
-                response = model.generate_content([system_prompt, formatted_prompt])
-            else:
-                response = model.generate_content(formatted_prompt)
-
-            # Extract the generated text
-            generated_text = response.text
-
-            # Get token counts
-            prompt_tokens = self.count_tokens(prompt)
-            completion_tokens = self.count_tokens(generated_text)
-            total_tokens = prompt_tokens + completion_tokens
-
-            # Calculate cost
-            cost = self.estimate_cost(prompt, completion_tokens)
-
-            # Prepare the response
-            result = {
-                "text": generated_text,
-                "cost": cost,
-                "usage": {
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": total_tokens,
-                },
-            }
-
-            return self.validate_response(result)
-
-        except Exception as e:
-            error_message = str(e)
-
-            # Handle rate limit errors
-            if (
-                "rate limit" in error_message.lower()
-                or "quota" in error_message.lower()
-            ):
-                raise RateLimitError(f"Google API rate limit exceeded: {error_message}")
-
-            # Handle other API errors
-            raise ProviderAPIError(
-                f"Error generating completion with Google API: {error_message}", e
-            )

indoxRouter/providers/llama.py

@@ -1,164 +0,0 @@
-import os
-import json
-import requests
-from typing import Dict, Any, Optional, List
-from .base_provider import BaseProvider
-
-
-class Provider(BaseProvider):
-    def __init__(self, api_key: str, model_name: str):
-        """
-        Initialize the Llama provider with API key and model name.
-
-        Args:
-            api_key (str): The API key for authentication
-            model_name (str): The name of the model to use
-        """
-        super().__init__(api_key, model_name)
-        self.base_url = os.environ.get("LLAMA_API_BASE", "https://llama-api.meta.ai/v1")
-        self.headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        }
-        self.model_config = self._load_model_config()
-
-    def _load_model_config(self) -> Dict[str, Any]:
-        """
-        Load the model configuration from the JSON file.
-
-        Returns:
-            Dict[str, Any]: The model configuration
-        """
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        config_path = os.path.join(current_dir, "llama.json")
-
-        with open(config_path, "r") as f:
-            models = json.load(f)
-
-        for model in models:
-            if model["modelName"] == self.model_name:
-                return model
-
-        raise ValueError(f"Model {self.model_name} not found in configuration")
-
-    def estimate_cost(self, prompt: str, max_tokens: int = 100) -> float:
-        """
-        Estimate the cost of generating a completion.
-
-        Args:
-            prompt (str): The prompt to generate a completion for
-            max_tokens (int, optional): The maximum number of tokens to generate. Defaults to 100.
-
-        Returns:
-            float: The estimated cost in USD
-        """
-        input_tokens = self.count_tokens(prompt)
-        input_cost = (input_tokens / 1000) * self.model_config["inputPricePer1KTokens"]
-        output_cost = (max_tokens / 1000) * self.model_config["outputPricePer1KTokens"]
-        return input_cost + output_cost
-
-    def count_tokens(self, text: str) -> int:
-        """
-        Count the number of tokens in a text.
-        This is a simple approximation. For more accurate counts, consider using a tokenizer.
-
-        Args:
-            text (str): The text to count tokens for
-
-        Returns:
-            int: The number of tokens
-        """
-        # Simple approximation: 1 token ≈ 4 characters
-        return len(text) // 4
-
-    def generate(
-        self,
-        prompt: str,
-        max_tokens: int = 100,
-        temperature: float = 0.7,
-        top_p: float = 1.0,
-        frequency_penalty: float = 0.0,
-        presence_penalty: float = 0.0,
-        stop: Optional[List[str]] = None,
-    ) -> Dict[str, Any]:
-        """
-        Generate a completion for the given prompt.
-
-        Args:
-            prompt (str): The prompt to generate a completion for
-            max_tokens (int, optional): The maximum number of tokens to generate. Defaults to 100.
-            temperature (float, optional): The temperature for sampling. Defaults to 0.7.
-            top_p (float, optional): The top-p value for nucleus sampling. Defaults to 1.0.
-            frequency_penalty (float, optional): The frequency penalty. Defaults to 0.0.
-            presence_penalty (float, optional): The presence penalty. Defaults to 0.0.
-            stop (Optional[List[str]], optional): A list of stop sequences. Defaults to None.
-
-        Returns:
-            Dict[str, Any]: The generated completion
-        """
-        # Format the prompt according to the model's template
-        prompt_template = self.model_config.get("promptTemplate", "%1%2")
-        formatted_prompt = prompt_template.replace("%1", prompt).replace("%2", "")
-
-        # Prepare the request payload
-        payload = {
-            "model": self.model_config.get("companyModelName", self.model_name),
-            "prompt": formatted_prompt,
-            "max_tokens": max_tokens,
-            "temperature": temperature,
-            "top_p": top_p,
-            "frequency_penalty": frequency_penalty,
-            "presence_penalty": presence_penalty,
-        }
-
-        if stop:
-            payload["stop"] = stop
-
-        # Make the API request
-        try:
-            response = requests.post(
-                f"{self.base_url}/completions", headers=self.headers, json=payload
-            )
-            response.raise_for_status()
-            result = response.json()
-
-            # Calculate the cost
-            input_tokens = result.get("usage", {}).get(
-                "prompt_tokens", self.count_tokens(prompt)
-            )
-            output_tokens = result.get("usage", {}).get("completion_tokens", 0)
-            input_cost = (input_tokens / 1000) * self.model_config[
-                "inputPricePer1KTokens"
-            ]
-            output_cost = (output_tokens / 1000) * self.model_config[
-                "outputPricePer1KTokens"
-            ]
-            total_cost = input_cost + output_cost
-
-            # Format the response
-            return self.validate_response(
-                {
-                    "text": result.get("choices", [{}])[0].get("text", ""),
-                    "cost": total_cost,
-                    "usage": {
-                        "input_tokens": input_tokens,
-                        "output_tokens": output_tokens,
-                        "input_cost": input_cost,
-                        "output_cost": output_cost,
-                    },
-                    "raw_response": result,
-                }
-            )
-
-        except requests.exceptions.RequestException as e:
-            return {
-                "text": f"Error: {str(e)}",
-                "cost": 0,
-                "usage": {
-                    "input_tokens": 0,
-                    "output_tokens": 0,
-                    "input_cost": 0,
-                    "output_cost": 0,
-                },
-                "error": str(e),
-            }

indoxRouter/providers/meta.py

@@ -1,227 +0,0 @@
-import json
-import os
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-import requests
-
-from .base_provider import BaseProvider
-from ..utils.exceptions import ModelNotFoundError, ProviderAPIError, RateLimitError
-
-
-class Provider(BaseProvider):
-    """
-    Meta Llama provider implementation
-    """
-
-    def __init__(self, api_key: str, model_name: str):
-        """
-        Initialize the Meta provider
-
-        Args:
-            api_key: Meta API key
-            model_name: Model name (e.g., llama-3-70b-instruct)
-        """
-        super().__init__(api_key, model_name)
-
-        # Load model configuration
-        self.model_config = self._load_model_config(model_name)
-
-        # Meta API base URL
-        self.api_base = os.environ.get("META_API_BASE", "https://api.meta.ai/v1")
-
-        # Default generation parameters
-        self.default_params = {
-            "temperature": 0.7,
-            "top_p": 0.9,
-            "max_tokens": 1024,
-        }
-
-    def _load_model_config(self, model_name: str) -> Dict[str, Any]:
-        """
-        Load model configuration from the JSON file
-
-        Args:
-            model_name: Model name to load configuration for
-
-        Returns:
-            Model configuration dictionary
-
-        Raises:
-            ModelNotFoundError: If the model is not found in the configuration
-        """
-        config_path = Path(__file__).parent / "meta.json"
-
-        try:
-            with open(config_path, "r") as f:
-                models = json.load(f)
-
-            for model in models:
-                if model.get("modelName") == model_name:
-                    return model
-
-            raise ModelNotFoundError(f"Model {model_name} not found in Meta provider")
-
-        except FileNotFoundError:
-            raise ModelNotFoundError(f"Meta provider configuration file not found")
-        except json.JSONDecodeError:
-            raise ModelNotFoundError(
-                f"Invalid JSON in Meta provider configuration file"
-            )
-
-    def estimate_cost(self, prompt: str, max_tokens: int) -> float:
-        """
-        Estimate the cost of generating a completion
-
-        Args:
-            prompt: Prompt text
-            max_tokens: Maximum number of tokens to generate
-
-        Returns:
-            Estimated cost in USD
-        """
-        # Count tokens in the prompt
-        prompt_tokens = self.count_tokens(prompt)
-
-        # Calculate cost based on input and output pricing
-        input_cost = (prompt_tokens / 1000) * self.model_config.get(
-            "inputPricePer1KTokens", 0
-        )
-        output_cost = (max_tokens / 1000) * self.model_config.get(
-            "outputPricePer1KTokens", 0
-        )
-
-        return input_cost + output_cost
-
-    def count_tokens(self, text: str) -> int:
-        """
-        Count the number of tokens in a text
-
-        Args:
-            text: Text to count tokens for
-
-        Returns:
-            Number of tokens
-        """
-        # Meta doesn't provide a direct token counting API
-        # This is a rough approximation - in production, consider using a tokenizer library
-        return len(text.split()) * 1.3  # Rough approximation
-
-    def generate(self, prompt: str, **kwargs) -> Dict[str, Any]:
-        """
-        Generate a completion for the given prompt
-
-        Args:
-            prompt: Prompt text
-            **kwargs: Additional parameters for the generation
-
-        Returns:
-            Dictionary containing the generated text, cost, and usage statistics
-
-        Raises:
-            ProviderAPIError: If there's an error with the provider API
-            RateLimitError: If the provider's rate limit is exceeded
-        """
-        try:
-            # Get generation parameters
-            max_tokens = kwargs.get("max_tokens", self.default_params["max_tokens"])
-            temperature = kwargs.get("temperature", self.default_params["temperature"])
-            top_p = kwargs.get("top_p", self.default_params["top_p"])
-
-            # Prepare system prompt if provided
-            system_prompt = kwargs.get(
-                "system_prompt", self.model_config.get("systemPrompt", "")
-            )
-
-            # Format the prompt using the template if available
-            prompt_template = self.model_config.get("promptTemplate", "")
-            if prompt_template and "%1" in prompt_template:
-                formatted_prompt = prompt_template.replace("%1", prompt)
-            else:
-                formatted_prompt = prompt
-
-            # Prepare the request payload
-            payload = {
-                "model": self.model_name,
-                "messages": [],
-                "temperature": temperature,
-                "top_p": top_p,
-                "max_tokens": max_tokens,
-            }
-
-            # Add system message if provided
-            if system_prompt:
-                payload["messages"].append({"role": "system", "content": system_prompt})
-
-            # Add user message
-            payload["messages"].append({"role": "user", "content": formatted_prompt})
-
-            # Make the API request
-            headers = {
-                "Authorization": f"Bearer {self.api_key}",
-                "Content-Type": "application/json",
-            }
-
-            response = requests.post(
-                f"{self.api_base}/chat/completions",
-                headers=headers,
-                json=payload,
-                timeout=60,
-            )
-
-            # Check for errors
-            if response.status_code != 200:
-                error_message = (
-                    response.json().get("error", {}).get("message", "Unknown error")
-                )
-
-                if response.status_code == 429:
-                    raise RateLimitError(
-                        f"Meta API rate limit exceeded: {error_message}"
-                    )
-                else:
-                    raise ProviderAPIError(f"Meta API error: {error_message}")
-
-            # Parse the response
-            response_data = response.json()
-
-            # Extract the generated text
-            generated_text = (
-                response_data.get("choices", [{}])[0]
-                .get("message", {})
-                .get("content", "")
-            )
-
-            # Get token usage
-            usage = response_data.get("usage", {})
-            prompt_tokens = usage.get(
-                "prompt_tokens", self.count_tokens(formatted_prompt)
-            )
-            completion_tokens = usage.get(
-                "completion_tokens", self.count_tokens(generated_text)
-            )
-            total_tokens = usage.get("total_tokens", prompt_tokens + completion_tokens)
-
-            # Calculate cost
-            cost = self.estimate_cost(formatted_prompt, completion_tokens)
-
-            # Prepare the response
-            result = {
-                "text": generated_text,
-                "cost": cost,
-                "usage": {
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": total_tokens,
-                },
-            }
-
-            return self.validate_response(result)
-
-        except RateLimitError:
-            # Re-raise rate limit errors
-            raise
-        except Exception as e:
-            # Handle other errors
-            raise ProviderAPIError(
-                f"Error generating completion with Meta API: {str(e)}", e
-            )