multillm-core 0.1.0__py3-none-any.whl

multillm/__init__.py

@@ -0,0 +1,13 @@
+from .exceptions import MultiLLMError
+from .factory import create_client
+from .providers.base import BaseLLMClient
+from .schemas import LLMResponse
+from .version import __version__
+
+__all__ = [
+    "create_client",
+    "BaseLLMClient",
+    "LLMResponse",
+    "MultiLLMError",
+    "__version__",
+]

multillm/exceptions.py

@@ -0,0 +1,46 @@
+class MultiLLMError(Exception):
+    """Base exception for all multillm errors."""
+
+    pass
+
+
+class ProviderNotFoundError(MultiLLMError):
+    """Raised when a requested provider is not found."""
+
+    pass
+
+
+class SDKNotInstalledError(MultiLLMError):
+    """Raised when a provider's SDK is not installed."""
+
+    def __init__(self, provider: str, package_name: str):
+        self.provider = provider
+        self.package_name = package_name
+        super().__init__(
+            f"SDK for '{provider}' is not installed. Please install it using: "
+            f"pip install 'multillm-core[{package_name}]'"
+        )
+
+
+class APIError(MultiLLMError):
+    """Base for provider-side API errors."""
+
+    pass
+
+
+class AuthenticationError(APIError):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class RateLimitError(APIError):
+    """Raised when rate limits are exceeded."""
+
+    pass
+
+
+class InvalidRequestError(APIError):
+    """Raised when the request is invalid."""
+
+    pass

multillm/factory.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+from .exceptions import ProviderNotFoundError
+from .providers.anthropic import AnthropicClient
+from .providers.base import BaseLLMClient
+from .providers.gemini import GeminiClient
+from .providers.openai import OpenAIClient
+
+PROVIDER_MAP: dict[str, type[BaseLLMClient]] = {
+    "openai": OpenAIClient,
+    "anthropic": AnthropicClient,
+    "gemini": GeminiClient,
+    "google": GeminiClient,
+}
+
+
+def create_client(provider: str, **kwargs: Any) -> BaseLLMClient:
+    """
+    Factory function to create an LLM client.
+
+    Args:
+        provider: Name of the provider ('openai', 'anthropic', 'gemini').
+        **kwargs: Arguments passed to the provider client constructor (e.g., api_key).
+
+    Returns:
+        An instance of BaseLLMClient.
+
+    Raises:
+        ProviderNotFoundError: If the provider is not supported.
+    """
+    provider_key = provider.lower()
+    if provider_key not in PROVIDER_MAP:
+        raise ProviderNotFoundError(
+            f"Provider '{provider}' is not supported. "
+            f"Available providers: {', '.join(PROVIDER_MAP.keys())}"
+        )
+
+    client_cls = PROVIDER_MAP[provider_key]
+    return client_cls(**kwargs)

multillm/providers/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseLLMClient
+
+__all__ = ["BaseLLMClient"]

multillm/providers/anthropic.py

@@ -0,0 +1,59 @@
+from typing import Any, NoReturn, Optional
+
+from ..exceptions import (
+    APIError,
+    AuthenticationError,
+    InvalidRequestError,
+    RateLimitError,
+    SDKNotInstalledError,
+)
+from ..schemas import LLMResponse, TokenUsage
+from .base import BaseLLMClient
+
+
+class AnthropicClient(BaseLLMClient):
+    """Anthropic provider client."""
+
+    def __init__(self, api_key: Optional[str] = None, **kwargs: Any):
+        try:
+            import anthropic
+
+            self._client = anthropic.AsyncAnthropic(api_key=api_key, **kwargs)
+        except ImportError:
+            raise SDKNotInstalledError("anthropic", "anthropic")
+
+    async def generate(self, model: str, prompt: str, **kwargs: Any) -> LLMResponse:
+        try:
+            response = await self._client.messages.create(
+                model=model,
+                max_tokens=kwargs.get("max_tokens", 4096),
+                messages=[{"role": "user", "content": prompt}],
+                **{k: v for k, v in kwargs.items() if k != "max_tokens"},
+            )
+
+            text = response.content[0].text
+
+            usage = TokenUsage(
+                input_tokens=response.usage.input_tokens,
+                output_tokens=response.usage.output_tokens,
+                total_tokens=response.usage.input_tokens + response.usage.output_tokens,
+            )
+
+            return LLMResponse(
+                text=text, provider="anthropic", model=model, usage=usage, raw=response
+            )
+        except Exception as e:
+            return self._handle_error(e)
+
+    def _handle_error(self, e: Exception) -> NoReturn:
+        import anthropic
+
+        if isinstance(e, anthropic.AuthenticationError):
+            raise AuthenticationError(str(e))
+        if isinstance(e, anthropic.RateLimitError):
+            raise RateLimitError(str(e))
+        if isinstance(e, anthropic.BadRequestError):
+            raise InvalidRequestError(str(e))
+        if isinstance(e, anthropic.APIError):
+            raise APIError(str(e))
+        raise APIError(f"Unexpected Anthropic error: {str(e)}")

multillm/providers/base.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from ..schemas import LLMResponse
+
+
+class BaseLLMClient(ABC):
+    """Base class for all LLM provider clients."""
+
+    @abstractmethod
+    async def generate(self, model: str, prompt: str, **kwargs: Any) -> LLMResponse:
+        """
+        Generate a response from the LLM.
+
+        Args:
+            model: The model name to use.
+            prompt: The input text prompt.
+            **kwargs: Provider-specific arguments.
+
+        Returns:
+            LLMResponse object.
+        """
+        pass
+
+    async def stream(
+        self, model: str, prompt: str, **kwargs: Any
+    ) -> AsyncGenerator[str, None]:
+        """
+        Stream back the response from the LLM.
+
+        Args:
+            model: The model name to use.
+            prompt: The input text prompt.
+            **kwargs: Provider-specific arguments.
+
+        Yields:
+            Response chunks text.
+        """
+        raise NotImplementedError(
+            f"Streaming is not implemented for {self.__class__.__name__}"
+        )

multillm/providers/gemini.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional
+
+from ..exceptions import APIError, SDKNotInstalledError
+from ..schemas import LLMResponse, TokenUsage
+from .base import BaseLLMClient
+
+
+class GeminiClient(BaseLLMClient):
+    """Google Gemini provider client."""
+
+    def __init__(self, api_key: Optional[str] = None, **kwargs: Any):
+        try:
+            from google import genai
+
+            self._client = genai.Client(api_key=api_key, **kwargs)
+        except ImportError:
+            raise SDKNotInstalledError("google-genai", "gemini")
+
+    async def generate(self, model: str, prompt: str, **kwargs: Any) -> LLMResponse:
+        try:
+            # The new SDK uses client.aio.models.generate_content for async
+            response = await self._client.aio.models.generate_content(
+                model=model, contents=prompt, **kwargs
+            )
+
+            text = response.text or ""
+            usage = TokenUsage()
+
+            if hasattr(response, "usage_metadata") and response.usage_metadata:
+                usage = TokenUsage(
+                    input_tokens=getattr(
+                        response.usage_metadata, "prompt_token_count", 0
+                    ),
+                    output_tokens=getattr(
+                        response.usage_metadata, "candidates_token_count", 0
+                    ),
+                    total_tokens=getattr(
+                        response.usage_metadata, "total_token_count", 0
+                    ),
+                )
+
+            return LLMResponse(
+                text=text, provider="gemini", model=model, usage=usage, raw=response
+            )
+        except Exception as e:
+            raise APIError(f"Gemini error: {str(e)}")

multillm/providers/openai.py

@@ -0,0 +1,57 @@
+from typing import Any, NoReturn, Optional
+
+from ..exceptions import (
+    APIError,
+    AuthenticationError,
+    InvalidRequestError,
+    RateLimitError,
+    SDKNotInstalledError,
+)
+from ..schemas import LLMResponse, TokenUsage
+from .base import BaseLLMClient
+
+
+class OpenAIClient(BaseLLMClient):
+    """OpenAI provider client."""
+
+    def __init__(self, api_key: Optional[str] = None, **kwargs: Any):
+        try:
+            import openai
+
+            self._client = openai.AsyncOpenAI(api_key=api_key, **kwargs)
+        except ImportError:
+            raise SDKNotInstalledError("openai", "openai")
+
+    async def generate(self, model: str, prompt: str, **kwargs: Any) -> LLMResponse:
+        try:
+            response = await self._client.chat.completions.create(
+                model=model, messages=[{"role": "user", "content": prompt}], **kwargs
+            )
+
+            choice = response.choices[0]
+            text = choice.message.content or ""
+
+            usage = TokenUsage(
+                input_tokens=response.usage.prompt_tokens,
+                output_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+            )
+
+            return LLMResponse(
+                text=text, provider="openai", model=model, usage=usage, raw=response
+            )
+        except Exception as e:
+            return self._handle_error(e)
+
+    def _handle_error(self, e: Exception) -> NoReturn:
+        import openai
+
+        if isinstance(e, openai.AuthenticationError):
+            raise AuthenticationError(str(e))
+        if isinstance(e, openai.RateLimitError):
+            raise RateLimitError(str(e))
+        if isinstance(e, openai.BadRequestError):
+            raise InvalidRequestError(str(e))
+        if isinstance(e, openai.APIError):
+            raise APIError(str(e))
+        raise APIError(f"Unexpected OpenAI error: {str(e)}")

multillm/schemas.py

@@ -0,0 +1,23 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class TokenUsage(BaseModel):
+    """Token usage statistics."""
+
+    input_tokens: int = Field(default=0, description="Number of tokens in the input.")
+    output_tokens: int = Field(default=0, description="Number of tokens in the output.")
+    total_tokens: Optional[int] = Field(default=None, description="Total tokens used.")
+
+
+class LLMResponse(BaseModel):
+    """Unified response model for all LLM providers."""
+
+    text: str = Field(..., description="The generated text response.")
+    provider: str = Field(..., description="The name of the provider.")
+    model: str = Field(..., description="The model name used.")
+    usage: TokenUsage = Field(
+        default_factory=TokenUsage, description="Token usage details."
+    )
+    raw: Any = Field(None, description="The raw response from the provider's SDK.")

multillm/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

multillm_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: multillm-core
+Version: 0.1.0
+Summary: A unified interface for multiple LLM providers
+Author: Divas Rajan
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: google-genai>=1.47.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.10.0; extra == 'all'
+Requires-Dist: google-genai>=0.1.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.10.0; extra == 'anthropic'
+Provides-Extra: gemini
+Requires-Dist: google-genai>=0.1.0; extra == 'gemini'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# multillm-core
+
+A unified interface for multiple LLM providers (OpenAI, Anthropic, Gemini).
+
+## Installation
+
+```bash
+pip install multillm-core
+```
+
+### Install with specific providers:
+
+```bash
+pip install "multillm-core[openai]"
+pip install "multillm-core[anthropic]"
+pip install "multillm-core[gemini]"
+pip install "multillm-core[all]"
+```
+
+## Example Usage
+
+```python
+import asyncio
+from multillm import create_client
+
+async def main():
+    client = create_client("openai", api_key="your-key")
+    response = await client.generate(
+        model="gpt-4o",
+        prompt="Explain quantum entanglement in one sentence."
+    )
+    print(f"[{response.provider}] {response.text}")
+    print(f"Usage: {response.usage}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Supported Providers
+- OpenAI
+- Anthropic
+- Google Gemini
+
+## License
+MIT

multillm_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+multillm/__init__.py,sha256=wCArBQoBBqzJrNy5oknONDCVqKshYKl7PZk719iGQns,297
+multillm/exceptions.py,sha256=rbFKQLRjLp8zSMwZK3VVRSUMzaPBFTifxzZU0fzghcQ,983
+multillm/factory.py,sha256=DZHUMCX6wDfwyL-C_GDrbHCs-9oddbAqEVY2YyYn7P0,1175
+multillm/schemas.py,sha256=cI-tIkpnEmcHt6PdGUuCkWOn4kedtfta4YsNRbWRXaY,890
+multillm/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+multillm/providers/__init__.py,sha256=EvfbkIzjIgrtqU9jzs9dvp7eZzwpaagXlZ6xONZhlTY,61
+multillm/providers/anthropic.py,sha256=gdeR0q_jaUopAvNiJEcgECMXR3DNznRR06qgCRK_jCQ,2050
+multillm/providers/base.py,sha256=qAooArEj93ke7KAwTvMD7NiS5bP5W5JVC8tDPONDaVc,1106
+multillm/providers/gemini.py,sha256=KOg2i34UNn5VCOnDL9tQSOvi5hCX5lqhyezQLo1Uhrw,1686
+multillm/providers/openai.py,sha256=x0uml603T4JDST89ZMwGXGRGZC6gxIjP0bna8gDMJlo,1895
+multillm_core-0.1.0.dist-info/METADATA,sha256=9iXHebRMtSUDP8VtRsko_zhMYJUBl7wvpyqYOJB6fxs,1670
+multillm_core-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+multillm_core-0.1.0.dist-info/RECORD,,

multillm_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any