lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/integrations/groq_/api_endpoints/data_models.py

@@ -1,187 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-
-class GroqEndpointRequestBody(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class GroqEndpointResponseBody(BaseModel):
-    model_config = ConfigDict(
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class GroqEndpointQueryParam(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class GroqEndpointPathParam(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class GroqChatMessage(BaseModel):
-    role: str = Field(description="The role of the message sender")
-    content: str = Field(description="The content of the message")
-    name: str | None = Field(
-        default=None, description="Optional name for the message sender"
-    )
-
-
-class GroqChatCompletionRequest(GroqEndpointRequestBody):
-    messages: list[GroqChatMessage] = Field(
-        description="List of messages in the conversation"
-    )
-    model: str = Field(description="ID of the model to use")
-    temperature: float | None = Field(
-        default=1.0,
-        description="Sampling temperature between 0 and 2",
-        ge=0.0,
-        le=2.0,
-    )
-    top_p: float | None = Field(
-        default=1.0,
-        description="Nucleus sampling threshold",
-        ge=0.0,
-        le=1.0,
-    )
-    n: int | None = Field(
-        default=1,
-        description="Number of completions to generate",
-        ge=1,
-    )
-    stream: bool | None = Field(
-        default=False,
-        description="Whether to stream the response",
-    )
-    stop: str | list[str] | None = Field(
-        default=None,
-        description="Sequences where the API will stop generating",
-    )
-    max_tokens: int | None = Field(
-        default=None,
-        description="Maximum number of tokens to generate",
-        ge=1,
-    )
-    presence_penalty: float | None = Field(
-        default=0.0,
-        description="Presence penalty",
-        ge=-2.0,
-        le=2.0,
-    )
-    frequency_penalty: float | None = Field(
-        default=0.0,
-        description="Frequency penalty",
-        ge=-2.0,
-        le=2.0,
-    )
-    logit_bias: dict[str, float] | None = Field(
-        default=None,
-        description="Modify token likelihoods",
-    )
-    user: str | None = Field(
-        default=None,
-        description="Unique identifier for the end user",
-    )
-
-    @model_validator(mode="after")
-    def validate_messages(self):
-        if not self.messages:
-            raise ValueError("Messages list cannot be empty")
-
-        # Validate roles
-        valid_roles = {"system", "user", "assistant"}
-        for msg in self.messages:
-            if msg.role not in valid_roles:
-                raise ValueError(
-                    f"Invalid role: {msg.role}. Must be one of {valid_roles}"
-                )
-
-        return self
-
-
-class GroqAudioRequest(GroqEndpointRequestBody):
-    model: str = Field(description="ID of the model to use")
-    file: str = Field(description="Audio file to process")
-    language: str | None = Field(
-        default=None,
-        description="Language of the audio (ISO-639-1)",
-    )
-    prompt: str | None = Field(
-        default=None,
-        description="Text to guide the model",
-    )
-    response_format: str | None = Field(
-        default="json",
-        description="Response format (json, text, or verbose_json)",
-    )
-    temperature: float | None = Field(
-        default=0,
-        description="Sampling temperature",
-        ge=0.0,
-        le=1.0,
-    )
-    timestamp_granularities: list[str] | None = Field(
-        default=["segment"],
-        description="Timestamp granularities (word or segment)",
-    )
-
-
-class GroqChatCompletionResponse(GroqEndpointResponseBody):
-    id: str = Field(description="Unique identifier for the completion")
-    object: str = Field(description="Object type")
-    created: int = Field(description="Unix timestamp of creation")
-    model: str = Field(description="Model used")
-    choices: list[dict] = Field(description="Generated completions")
-    usage: dict = Field(description="Token usage information")
-    system_fingerprint: str | None = Field(
-        description="System fingerprint for deterministic results"
-    )
-
-
-class GroqAudioResponse(GroqEndpointResponseBody):
-    text: str = Field(description="Transcribed or translated text")
-    x_groq: dict = Field(description="Groq-specific metadata")
-
-
-# Request model mapping for iModel
-GROQ_REQUEST_MODELS = {
-    "create_chat_completion": {
-        "request_body": GroqChatCompletionRequest,
-    },
-    "create_transcription": {
-        "request_body": GroqAudioRequest,
-    },
-    "create_translation": {
-        "request_body": GroqAudioRequest,
-    },
-    "chat/completions": {
-        "request_body": GroqChatCompletionRequest,
-    },
-    "audio/transcriptions": {
-        "request_body": GroqAudioRequest,
-    },
-    "audio/translations": {
-        "request_body": GroqAudioRequest,
-    },
-}

lionagi/integrations/groq_/api_endpoints/groq_request.py

@@ -1,288 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-import re
-from collections.abc import AsyncGenerator
-from os import getenv
-from typing import Any
-
-import aiohttp
-from pydantic import BaseModel, Field, field_validator
-
-from .data_models import (
-    GroqEndpointPathParam,
-    GroqEndpointQueryParam,
-    GroqEndpointRequestBody,
-)
-from .response_utils import match_response
-
-GROQ_BASE_URL = "https://api.groq.com/openai/v1"
-DEFAULT_TIMEOUT = 30  # seconds
-
-
-class GroqRequest(BaseModel):
-    api_key: str = Field(
-        description="API key for authentication", exclude=True
-    )
-    endpoint: str = Field(description="API endpoint")
-    method: str = Field(description="HTTP method")
-    content_type: str | None = Field(
-        default="application/json", description="Content type for the request"
-    )
-    timeout: float = Field(
-        default=DEFAULT_TIMEOUT,
-        description="Request timeout in seconds",
-        ge=0,
-    )
-
-    model_config = {
-        "arbitrary_types_allowed": True,
-        "extra": "allow",  # Allow extra attributes for mocking
-    }
-
-    @field_validator("api_key")
-    @classmethod
-    def validate_api_key(cls, v: str) -> str:
-        """Validate API key format."""
-        # First try to get from env if v looks like an env var
-        if re.match(r"^[A-Z_][A-Z0-9_]*$", v):
-            env_value = getenv(v)
-            if env_value:
-                v = env_value
-
-        # Validate key format
-        if not v.startswith(("groq_", "gsk_")):
-            raise ValueError("Invalid Groq API key format")
-        return v
-
-    def get_headers(self) -> dict[str, str]:
-        """Get headers for the request."""
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-        }
-        if self.content_type:
-            headers["Content-Type"] = self.content_type
-        return headers
-
-    def get_endpoint(
-        self, path_param: GroqEndpointPathParam | None = None
-    ) -> str:
-        """Get the formatted endpoint URL."""
-        endpoint = self.endpoint
-        if path_param:
-            try:
-                endpoint = endpoint.format(**path_param.model_dump())
-            except KeyError as e:
-                raise ValueError(f"Missing path parameter: {e}")
-        return f"{GROQ_BASE_URL}/{endpoint}"
-
-    async def invoke(
-        self,
-        request_body: GroqEndpointRequestBody | None = None,
-        params: GroqEndpointQueryParam | None = None,
-        form_data: dict[str, Any] | None = None,
-        path_param: GroqEndpointPathParam | None = None,
-        output_file: str | None = None,
-        with_response_header: bool = False,
-        parse_response: bool = True,
-        **kwargs,
-    ) -> Any:
-        """Make a request to the Groq API."""
-        url = self.get_endpoint(path_param)
-        headers = self.get_headers()
-        timeout = aiohttp.ClientTimeout(total=self.timeout)
-
-        # Convert Pydantic models to dict
-        json_data = (
-            request_body.model_dump(exclude_unset=True)
-            if request_body
-            else None
-        )
-        params = params.model_dump(exclude_unset=True) if params else None
-
-        try:
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                if form_data:
-                    data = aiohttp.FormData()
-                    for key, value in form_data.items():
-                        data.add_field(key, value)
-                    async with session.request(
-                        self.method,
-                        url,
-                        headers=headers,
-                        data=data,
-                        params=params,
-                    ) as response:
-                        return await self._handle_response(
-                            response,
-                            output_file,
-                            with_response_header,
-                            parse_response,
-                        )
-                else:
-                    async with session.request(
-                        self.method,
-                        url,
-                        headers=headers,
-                        json=json_data,
-                        params=params,
-                    ) as response:
-                        return await self._handle_response(
-                            response,
-                            output_file,
-                            with_response_header,
-                            parse_response,
-                        )
-        except aiohttp.ClientError as e:
-            raise ConnectionError(f"Failed to connect to Groq API: {str(e)}")
-        except TimeoutError:
-            raise TimeoutError(
-                f"Request timed out after {self.timeout} seconds"
-            )
-
-    async def stream(
-        self,
-        request_body: GroqEndpointRequestBody | None = None,
-        output_file: str | None = None,
-        with_response_header: bool = False,
-    ) -> AsyncGenerator[dict[str, Any], None]:
-        """Stream response from the Groq API."""
-        if request_body and not getattr(request_body, "stream", False):
-            raise ValueError(
-                "Request does not support stream. "
-                "Only requests with stream=True are supported"
-            )
-
-        url = self.get_endpoint()
-        headers = self.get_headers()
-        timeout = aiohttp.ClientTimeout(total=self.timeout)
-
-        # Convert Pydantic model to dict
-        json_data = (
-            request_body.model_dump(exclude_unset=True)
-            if request_body
-            else None
-        )
-
-        try:
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.request(
-                    self.method, url, headers=headers, json=json_data
-                ) as response:
-                    if response.status != 200:
-                        error_text = await self._get_error_text(response)
-                        raise aiohttp.ClientResponseError(
-                            request_info=response.request_info,
-                            history=response.history,
-                            status=response.status,
-                            message=error_text,
-                            headers=response.headers,
-                        )
-
-                    file_handle = None
-                    if output_file:
-                        try:
-                            file_handle = open(output_file, "w")
-                        except Exception as e:
-                            raise ValueError(
-                                f"Failed to open output file {output_file}: {str(e)}"
-                            )
-
-                    try:
-                        async for line in response.content:
-                            if line:
-                                try:
-                                    line = line.decode("utf-8").strip()
-                                except UnicodeDecodeError:
-                                    import warnings
-
-                                    warnings.warn(
-                                        "Failed to decode response chunk"
-                                    )
-                                    continue
-
-                                if line.startswith("data: "):
-                                    line = line[6:]  # Remove "data: " prefix
-
-                                if line == "[DONE]":
-                                    break
-
-                                try:
-                                    chunk_data = json.loads(line)
-                                    if file_handle:
-                                        file_handle.write(
-                                            json.dumps(chunk_data) + "\n"
-                                        )
-                                    yield chunk_data
-                                except json.JSONDecodeError:
-                                    import warnings
-
-                                    warnings.warn(
-                                        f"Failed to parse response chunk: {line}"
-                                    )
-                                    continue
-
-                        if with_response_header:
-                            yield dict(response.headers)
-                    finally:
-                        if file_handle:
-                            file_handle.close()
-
-        except aiohttp.ClientError as e:
-            raise ConnectionError(f"Failed to connect to Groq API: {str(e)}")
-        except TimeoutError:
-            raise TimeoutError(
-                f"Stream timed out after {self.timeout} seconds"
-            )
-
-    async def _handle_response(
-        self,
-        response: aiohttp.ClientResponse,
-        output_file: str | None = None,
-        with_response_header: bool = False,
-        parse_response: bool = True,
-    ) -> Any:
-        """Handle the API response."""
-        if response.status != 200:
-            error_text = await self._get_error_text(response)
-            raise aiohttp.ClientResponseError(
-                request_info=response.request_info,
-                history=response.history,
-                status=response.status,
-                message=error_text,
-                headers=response.headers,
-            )
-
-        if output_file:
-            with open(output_file, "wb") as f:
-                async for chunk in response.content.iter_chunked(1024):
-                    f.write(chunk)
-            return None
-
-        response_body = await response.json()
-
-        if parse_response:
-            response_body = match_response(self, response_body)
-
-        if with_response_header:
-            return response_body, dict(response.headers)
-        return response_body
-
-    async def _get_error_text(self, response: aiohttp.ClientResponse) -> str:
-        """Extract error text from response."""
-        try:
-            error_json = await response.json()
-            return json.dumps(error_json)
-        except Exception:
-            try:
-                return await response.text()
-            except Exception:
-                return f"HTTP {response.status}"
-
-    def __repr__(self):
-        return (
-            f"GroqRequest(endpoint={self.endpoint}, method={self.method}, "
-            f"content_type={self.content_type})"
-        )

lionagi/integrations/groq_/api_endpoints/match_response.py

@@ -1,106 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any
-
-from .data_models import GroqAudioResponse, GroqChatCompletionResponse
-from .groq_request import GroqRequest
-
-
-def match_response(
-    request_model: GroqRequest,
-    response: dict[str, Any] | list[dict[str, Any]] | None,
-) -> dict[str, Any] | list[dict[str, Any]] | None:
-    """Match response to appropriate model and format."""
-    if response is None:
-        return None
-
-    endpoint = request_model.endpoint.split("/")[0]
-
-    # Chat completions endpoint
-    if endpoint == "chat":
-        if isinstance(response, dict):
-            # Single response
-            try:
-                # Validate and parse through Pydantic model
-                parsed = GroqChatCompletionResponse(**response)
-                # Return in consistent format
-                return {
-                    "choices": parsed.choices,
-                    "model": parsed.model,
-                    "usage": parsed.usage,
-                }
-            except Exception as e:
-                import warnings
-
-                warnings.warn(f"Failed to parse chat response: {str(e)}")
-                return response
-        else:
-            # Stream response list
-            result = []
-            for chunk in response:
-                if not isinstance(chunk, dict):
-                    continue
-
-                try:
-                    if "choices" in chunk:
-                        # Regular chunk with content
-                        result.append(
-                            {
-                                "choices": [
-                                    {
-                                        "delta": {
-                                            "content": choice.get(
-                                                "delta", {}
-                                            ).get("content", ""),
-                                            "role": "assistant",
-                                        }
-                                    }
-                                    for choice in chunk["choices"]
-                                ]
-                            }
-                        )
-
-                        # Add usage if present
-                        if "usage" in chunk:
-                            result[-1]["usage"] = chunk["usage"]
-
-                    elif "usage" in chunk:
-                        # Final chunk with usage stats
-                        result.append(
-                            {
-                                "choices": [
-                                    {
-                                        "delta": {
-                                            "content": "",
-                                            "role": "assistant",
-                                        },
-                                        "finish_reason": "stop",
-                                    }
-                                ],
-                                "usage": chunk["usage"],
-                            }
-                        )
-                except Exception as e:
-                    import warnings
-
-                    warnings.warn(f"Failed to parse stream chunk: {str(e)}")
-                    continue
-
-            return result
-
-    # Audio endpoints
-    elif endpoint == "audio":
-        try:
-            if isinstance(response, dict):
-                parsed = GroqAudioResponse(**response)
-                return {"text": parsed.text, "metadata": parsed.x_groq}
-        except Exception as e:
-            import warnings
-
-            warnings.warn(f"Failed to parse audio response: {str(e)}")
-            return response
-
-    # Default case
-    return response

lionagi/integrations/groq_/api_endpoints/response_utils.py

@@ -1,105 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any
-
-from .data_models import GroqAudioResponse, GroqChatCompletionResponse
-
-
-def match_response(
-    request_model: Any,
-    response: dict[str, Any] | list[dict[str, Any]] | None,
-) -> dict[str, Any] | list[dict[str, Any]] | None:
-    """Match response to appropriate model and format."""
-    if response is None:
-        return None
-
-    endpoint = request_model.endpoint.split("/")[0]
-
-    # Chat completions endpoint
-    if endpoint == "chat":
-        if isinstance(response, dict):
-            # Single response
-            try:
-                # Validate and parse through Pydantic model
-                parsed = GroqChatCompletionResponse(**response)
-                # Return in consistent format
-                return {
-                    "choices": parsed.choices,
-                    "model": parsed.model,
-                    "usage": parsed.usage,
-                }
-            except Exception as e:
-                import warnings
-
-                warnings.warn(f"Failed to parse chat response: {str(e)}")
-                return response
-        else:
-            # Stream response list
-            result = []
-            for chunk in response:
-                if not isinstance(chunk, dict):
-                    continue
-
-                try:
-                    if "choices" in chunk:
-                        # Regular chunk with content
-                        result.append(
-                            {
-                                "choices": [
-                                    {
-                                        "delta": {
-                                            "content": choice.get(
-                                                "delta", {}
-                                            ).get("content", ""),
-                                            "role": "assistant",
-                                        }
-                                    }
-                                    for choice in chunk["choices"]
-                                ]
-                            }
-                        )
-
-                        # Add usage if present
-                        if "usage" in chunk:
-                            result[-1]["usage"] = chunk["usage"]
-
-                    elif "usage" in chunk:
-                        # Final chunk with usage stats
-                        result.append(
-                            {
-                                "choices": [
-                                    {
-                                        "delta": {
-                                            "content": "",
-                                            "role": "assistant",
-                                        },
-                                        "finish_reason": "stop",
-                                    }
-                                ],
-                                "usage": chunk["usage"],
-                            }
-                        )
-                except Exception as e:
-                    import warnings
-
-                    warnings.warn(f"Failed to parse stream chunk: {str(e)}")
-                    continue
-
-            return result
-
-    # Audio endpoints
-    elif endpoint == "audio":
-        try:
-            if isinstance(response, dict):
-                parsed = GroqAudioResponse(**response)
-                return {"text": parsed.text, "metadata": parsed.x_groq}
-        except Exception as e:
-            import warnings
-
-            warnings.warn(f"Failed to parse audio response: {str(e)}")
-            return response
-
-    # Default case
-    return response