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

indoxRouter/providers/claude.py

@@ -1,177 +0,0 @@
-from typing import Dict, Any, Optional, List
-import json
-import os
-from pathlib import Path
-
-try:
-    import anthropic
-    from anthropic import Anthropic
-except ImportError:
-    raise ImportError(
-        "Anthropic package not installed. Install it with 'pip install anthropic'"
-    )
-
-from ..utils.exceptions import RateLimitError, ModelNotFoundError
-from .base_provider import BaseProvider
-
-
-class Provider(BaseProvider):
-    """
-    Anthropic (Claude) provider implementation
-    """
-
-    def __init__(self, api_key: str, model_name: str):
-        """
-        Initialize the Anthropic provider
-
-        Args:
-            api_key: Anthropic API key
-            model_name: Model name to use (e.g., 'claude-3-opus-20240229')
-        """
-        super().__init__(api_key, model_name)
-
-        # Initialize Anthropic client
-        self.client = Anthropic(api_key=api_key)
-
-        # Load model configuration
-        self.model_config = self._load_model_config(model_name)
-
-    def _load_model_config(self, model_name: str) -> Dict[str, Any]:
-        """
-        Load model configuration from JSON file
-
-        Args:
-            model_name: Model name
-
-        Returns:
-            Model configuration dictionary
-        """
-        # Get the path to the model configuration file
-        config_path = Path(__file__).parent / "claude.json"
-
-        # Load the configuration
-        with open(config_path, "r") as f:
-            models = json.load(f)
-
-        # Find the model configuration
-        for model in models:
-            if model.get("modelName") == model_name:
-                return model
-
-        # If model not found, raise an error
-        raise ModelNotFoundError(
-            f"Model {model_name} not found in Anthropic configuration"
-        )
-
-    def estimate_cost(self, prompt: str, max_tokens: int) -> float:
-        """
-        Estimate the cost of generating a completion
-
-        Args:
-            prompt: The prompt to generate a completion for
-            max_tokens: Maximum number of tokens to generate
-
-        Returns:
-            Estimated cost in credits
-        """
-        # Estimate token count (rough approximation)
-        prompt_tokens = self.count_tokens(prompt)
-
-        # Get pricing for the model
-        input_price = self.model_config.get("inputPricePer1KTokens", 0)
-        output_price = self.model_config.get("outputPricePer1KTokens", 0)
-
-        # Calculate cost
-        prompt_cost = (prompt_tokens / 1000) * input_price
-        completion_cost = (max_tokens / 1000) * output_price
-
-        return prompt_cost + completion_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 Anthropic's token counter if available
-            return anthropic.count_tokens(text)
-        except:
-            # Fallback to simple approximation
-            return len(text.split()) * 1.3
-
-    def generate(self, prompt: str, **kwargs) -> Dict[str, Any]:
-        """
-        Generate a completion using Anthropic
-
-        Args:
-            prompt: The prompt to generate a completion for
-            **kwargs: Additional parameters for the generation
-                - max_tokens: Maximum number of tokens to generate
-                - temperature: Sampling temperature (0.0 to 1.0)
-                - top_p: Nucleus sampling parameter (0.0 to 1.0)
-
-        Returns:
-            Dictionary containing the response text, cost, and other metadata
-        """
-        try:
-            # Extract parameters
-            max_tokens = kwargs.get("max_tokens", 1024)
-            temperature = kwargs.get("temperature", 0.7)
-            top_p = kwargs.get("top_p", 1.0)
-
-            # Format prompt using the template from model config
-            prompt_template = self.model_config.get(
-                "promptTemplate", "Human: %1\n\nAssistant: %2"
-            )
-            formatted_prompt = prompt_template.replace("%1", prompt).replace("%2", "")
-
-            # Get system prompt if available
-            system_prompt = self.model_config.get("systemPrompt", "")
-
-            # Make API call
-            response = self.client.messages.create(
-                model=self.model_name,
-                messages=[{"role": "user", "content": prompt}],
-                system=system_prompt if system_prompt else None,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                top_p=top_p,
-            )
-
-            # Extract response text
-            text = response.content[0].text
-
-            # Calculate actual cost
-            input_price = self.model_config.get("inputPricePer1KTokens", 0)
-            output_price = self.model_config.get("outputPricePer1KTokens", 0)
-
-            prompt_tokens = response.usage.input_tokens
-            completion_tokens = response.usage.output_tokens
-
-            prompt_cost = (prompt_tokens / 1000) * input_price
-            completion_cost = (completion_tokens / 1000) * output_price
-            total_cost = prompt_cost + completion_cost
-
-            # Return standardized response
-            return {
-                "text": text,
-                "cost": total_cost,
-                "usage": {
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": prompt_tokens + completion_tokens,
-                },
-                "model": self.model_name,
-            }
-
-        except anthropic.RateLimitError as e:
-            raise RateLimitError(f"Anthropic rate limit exceeded: {str(e)}")
-        except anthropic.APIError as e:
-            raise Exception(f"Anthropic API error: {str(e)}")
-        except Exception as e:
-            raise Exception(f"Error generating completion: {str(e)}")

indoxRouter/providers/cohere.py

@@ -1,171 +0,0 @@
-from typing import Dict, Any, Optional, List
-import json
-import os
-from pathlib import Path
-
-try:
-    import cohere
-    from cohere import ClientV2 as CohereClient
-except ImportError:
-    raise ImportError(
-        "Cohere package not installed. Install it with 'pip install cohere'"
-    )
-
-from ..utils.exceptions import RateLimitError, ModelNotFoundError
-from .base_provider import BaseProvider
-
-
-class Provider(BaseProvider):
-    """
-    Cohere provider implementation
-    """
-
-    def __init__(self, api_key: str, model_name: str):
-        """
-        Initialize the Cohere provider
-
-        Args:
-            api_key: Cohere API key
-            model_name: Model name to use (e.g., 'command-r-plus')
-        """
-        super().__init__(api_key, model_name)
-
-        # Initialize Cohere client
-        self.client = CohereClient(api_key=api_key)
-
-        # Load model configuration
-        self.model_config = self._load_model_config(model_name)
-
-    def _load_model_config(self, model_name: str) -> Dict[str, Any]:
-        """
-        Load model configuration from JSON file
-
-        Args:
-            model_name: Model name
-
-        Returns:
-            Model configuration dictionary
-        """
-        # Get the path to the model configuration file
-        config_path = Path(__file__).parent / "cohere.json"
-
-        # Load the configuration
-        with open(config_path, "r") as f:
-            models = json.load(f)
-
-        # Find the model configuration
-        for model in models:
-            if model.get("modelName") == model_name:
-                return model
-
-        # If model not found, raise an error
-        raise ModelNotFoundError(
-            f"Model {model_name} not found in Cohere configuration"
-        )
-
-    def estimate_cost(self, prompt: str, max_tokens: int) -> float:
-        """
-        Estimate the cost of generating a completion
-
-        Args:
-            prompt: The prompt to generate a completion for
-            max_tokens: Maximum number of tokens to generate
-
-        Returns:
-            Estimated cost in credits
-        """
-        # Estimate token count (rough approximation)
-        prompt_tokens = self.count_tokens(prompt)
-
-        # Get pricing for the model
-        input_price = self.model_config.get("inputPricePer1KTokens", 0)
-        output_price = self.model_config.get("outputPricePer1KTokens", 0)
-
-        # Calculate cost
-        prompt_cost = (prompt_tokens / 1000) * input_price
-        completion_cost = (max_tokens / 1000) * output_price
-
-        return prompt_cost + completion_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
-        """
-        # Simple approximation - in production, use a proper tokenizer
-        return len(text.split()) * 1.3
-
-    def generate(self, prompt: str, **kwargs) -> Dict[str, Any]:
-        """
-        Generate a completion using Cohere
-
-        Args:
-            prompt: The prompt to generate a completion for
-            **kwargs: Additional parameters for the generation
-                - max_tokens: Maximum number of tokens to generate
-                - temperature: Sampling temperature (0.0 to 2.0)
-                - top_p: Nucleus sampling parameter (0.0 to 1.0)
-                - system_prompt: System prompt to use
-
-        Returns:
-            Dictionary containing the response text, cost, and other metadata
-        """
-        try:
-            # Extract parameters
-            max_tokens = kwargs.get("max_tokens", 1024)
-            temperature = kwargs.get("temperature", 0.7)
-            top_p = kwargs.get("top_p", 1.0)
-            system_prompt = kwargs.get(
-                "system_prompt", self.model_config.get("systemPrompt", "")
-            )
-
-            # Prepare messages
-            messages = [{"role": "user", "content": prompt}]
-
-            # Make API call using the new format
-            response = self.client.chat(
-                model=self.model_name,
-                messages=messages,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                p=top_p,
-                system=system_prompt if system_prompt else None,
-            )
-
-            # Extract response text
-            text = response.text
-
-            # Calculate actual cost
-            input_price = self.model_config.get("inputPricePer1KTokens", 0)
-            output_price = self.model_config.get("outputPricePer1KTokens", 0)
-
-            prompt_tokens = response.meta.billed_units.input_tokens
-            completion_tokens = response.meta.billed_units.output_tokens
-
-            prompt_cost = (prompt_tokens / 1000) * input_price
-            completion_cost = (completion_tokens / 1000) * output_price
-            total_cost = prompt_cost + completion_cost
-
-            # Return standardized response
-            return {
-                "text": text,
-                "cost": total_cost,
-                "usage": {
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": prompt_tokens + completion_tokens,
-                },
-                "model": self.model_name,
-            }
-
-        except cohere.error.CohereAPIError as e:
-            if "rate limit" in str(e).lower():
-                raise RateLimitError(f"Cohere rate limit exceeded: {str(e)}")
-            raise Exception(f"Cohere API error: {str(e)}")
-        except Exception as e:
-            raise Exception(f"Error generating completion: {str(e)}")

indoxRouter/providers/databricks.py

@@ -1,166 +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 Databricks 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(
-            "DATABRICKS_API_BASE", "https://api.databricks.com/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, "databricks.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/deepseek.py

@@ -1,166 +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 Deepseek 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(
-            "DEEPSEEK_API_BASE", "https://api.deepseek.com/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, "deepseek.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),
-            }