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

lionagi/integrations/anthropic_/api_endpoints/api_request.py

@@ -1,277 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-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 (
-    AnthropicEndpointPathParam,
-    AnthropicEndpointQueryParam,
-    AnthropicEndpointRequestBody,
-)
-from .match_response import match_response
-
-
-class AnthropicRequest(BaseModel):
-    api_key: str = Field(
-        description="API key for authentication", exclude=True
-    )
-
-    endpoint: str = Field(description="Endpoint for request")
-
-    method: str = Field(description="HTTP method")
-
-    content_type: str | None = Field(
-        default=None, description="HTTP Content-Type"
-    )
-
-    api_version: str = Field(
-        default="2023-06-01", description="Anthropic API version"
-    )
-
-    model_config = {
-        "arbitrary_types_allowed": True,
-        "extra": "allow",  # Allow extra attributes for mocking
-    }
-
-    @field_validator("api_key")
-    @classmethod
-    def get_id(cls, value: str) -> str:
-        try:
-            if api_key := getenv(value):
-                return api_key
-            else:
-                return value
-        except Exception:
-            return value
-
-    def get_endpoint(self, path_param: AnthropicEndpointPathParam = None):
-        if path_param is None:
-            return self.endpoint
-        else:
-            return self.endpoint.format(**path_param.model_dump())
-
-    @property
-    def base_url(self):
-        return "https://api.anthropic.com/v1/"
-
-    async def invoke(
-        self,
-        json_data: AnthropicEndpointRequestBody = None,
-        params: AnthropicEndpointQueryParam = None,
-        path_param: AnthropicEndpointPathParam = None,
-        output_file: str = None,
-        with_response_header: bool = False,
-        parse_response: bool = True,
-    ) -> Any:
-        def get_headers():
-            headers = {
-                "x-api-key": self.api_key,
-                "anthropic-version": self.api_version,
-            }
-            if self.content_type:
-                headers["Content-Type"] = self.content_type
-            return headers
-
-        url = self.base_url + self.get_endpoint(path_param)
-        headers = get_headers()
-        json_data = (
-            json_data.model_dump(exclude_unset=True) if json_data else None
-        )
-        params = params.model_dump(exclude_unset=True) if params else None
-
-        async with aiohttp.ClientSession() as client:
-            async with client.request(
-                method=self.method,
-                url=url,
-                headers=headers,
-                json=json_data,
-                params=params,
-            ) as response:
-                if response.status != 200:
-                    try:
-                        error_text = await response.json()
-                    except Exception:
-                        error_text = await response.text()
-                    raise aiohttp.ClientResponseError(
-                        request_info=response.request_info,
-                        history=response.history,
-                        status=response.status,
-                        message=f"{error_text}",
-                        headers=response.headers,
-                    )
-
-                # handle stream in messages
-                if json_data and json_data.get("stream"):
-                    response_body = []
-                    file_handle = None
-                    if output_file:
-                        try:
-                            file_handle = open(output_file, "w")
-                        except Exception as e:
-                            raise ValueError(
-                                f"Invalid to output the response "
-                                f"to {output_file}. Error:{e}"
-                            )
-
-                    try:
-                        async for chunk in response.content:
-                            chunk_str = chunk.decode("utf-8")
-                            if chunk_str.startswith("data: "):
-                                chunk_str = chunk_str[
-                                    6:
-                                ]  # Remove "data: " prefix
-                            if chunk_str.strip() == "[DONE]":
-                                continue
-                            try:
-                                chunk_data = json.loads(chunk_str)
-                                if file_handle:
-                                    file_handle.write(
-                                        json.dumps(chunk_data) + "\n"
-                                    )
-                                response_body.append(chunk_data)
-                            except json.JSONDecodeError:
-                                continue
-                    except Exception as e:
-                        raise e
-                    finally:
-                        if file_handle:
-                            file_handle.close()
-
-                    if parse_response:
-                        response_body = match_response(self, response_body)
-                    if with_response_header:
-                        return response_body, response.headers
-                    else:
-                        return response_body
-
-                if output_file:
-                    try:
-                        with open(output_file, "wb") as f:
-                            f.write(await response.read())
-                    except Exception as e:
-                        raise ValueError(
-                            f"Invalid to output the response "
-                            f"to {output_file}. Error:{e}"
-                        )
-
-                response_body = await response.json()
-
-                if parse_response:
-                    response_body = match_response(self, response_body)
-                if with_response_header:
-                    return response_body, response.headers
-                else:
-                    return response_body
-
-    async def stream(
-        self,
-        json_data: AnthropicEndpointRequestBody,
-        verbose: bool = True,
-        output_file: str = None,
-        with_response_header: bool = False,
-    ) -> AsyncGenerator[Any, None]:
-        if not getattr(json_data, "stream"):
-            raise ValueError(
-                "Request does not support stream. "
-                "Only messages requests with stream=True are supported"
-            )
-
-        def get_headers():
-            headers = {
-                "x-api-key": self.api_key,
-                "anthropic-version": self.api_version,
-            }
-            if self.content_type:
-                headers["Content-Type"] = self.content_type
-            return headers
-
-        url = self.base_url + self.get_endpoint()
-        headers = get_headers()
-        json_data = (
-            json_data.model_dump(exclude_unset=True) if json_data else None
-        )
-
-        try:
-            async with aiohttp.ClientSession() as client:
-                async with client.request(
-                    method=self.method,
-                    url=url,
-                    headers=headers,
-                    json=json_data,
-                ) as response:
-                    if response.status != 200:
-                        try:
-                            error_text = await response.json()
-                        except Exception:
-                            error_text = await response.text()
-                        raise aiohttp.ClientResponseError(
-                            request_info=response.request_info,
-                            history=response.history,
-                            status=response.status,
-                            message=f"{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"Invalid to output the response "
-                                f"to {output_file}. Error:{e}"
-                            )
-
-                    try:
-                        async for chunk in response.content:
-                            chunk_str = chunk.decode("utf-8")
-                            if chunk_str.startswith("data: "):
-                                chunk_str = chunk_str[
-                                    6:
-                                ]  # Remove "data: " prefix
-                            if chunk_str.strip() == "[DONE]":
-                                continue
-                            try:
-                                chunk_data = json.loads(chunk_str)
-                                if file_handle:
-                                    file_handle.write(
-                                        json.dumps(chunk_data) + "\n"
-                                    )
-
-                                # Print content when verbose is True
-                                if verbose:
-                                    if (
-                                        chunk_data.get("type")
-                                        == "content_block_delta"
-                                    ):
-                                        if text := chunk_data.get(
-                                            "delta", {}
-                                        ).get("text"):
-                                            print(text, end="", flush=True)
-
-                                yield chunk_data
-                            except json.JSONDecodeError:
-                                continue
-
-                        if with_response_header:
-                            yield response.headers
-                    except Exception as e:
-                        raise e
-                    finally:
-                        if file_handle:
-                            file_handle.close()
-        except Exception as e:
-            raise e
-
-    def __repr__(self):
-        return (
-            f"AnthropicRequest(endpoint={self.endpoint}, method={self.method}, "
-            f"content_type={self.content_type}, api_version={self.api_version})"
-        )

lionagi/integrations/anthropic_/api_endpoints/data_models.py

@@ -1,40 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import BaseModel, ConfigDict
-
-
-class AnthropicEndpointRequestBody(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class AnthropicEndpointResponseBody(BaseModel):
-    model_config = ConfigDict(
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class AnthropicEndpointQueryParam(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class AnthropicEndpointPathParam(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )

lionagi/integrations/anthropic_/api_endpoints/match_response.py

@@ -1,119 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-imported_models = {}
-
-
-def match_response(request_model, response: dict | list):
-    global imported_models
-
-    endpoint = request_model.endpoint
-    method = request_model.method
-
-    # Messages endpoint
-    if endpoint == "messages":
-        if isinstance(response, dict):
-            # Single message response
-            if "AnthropicMessageResponseBody" not in imported_models:
-                from .messages.response.response_body import (
-                    AnthropicMessageResponseBody,
-                )
-
-                imported_models["AnthropicMessageResponseBody"] = (
-                    AnthropicMessageResponseBody
-                )
-
-            # Convert to OpenAI-like format for AssistantResponse
-            if response.get("content") and len(response["content"]) > 0:
-                text_content = " ".join(
-                    block["text"]
-                    for block in response["content"]
-                    if block["type"] == "text"
-                )
-                return {
-                    "choices": [
-                        {
-                            "message": {
-                                "content": text_content,
-                                "role": "assistant",
-                            }
-                        }
-                    ],
-                    "model": response.get("model"),
-                    "usage": response.get("usage", {}),
-                }
-            return response
-        else:
-            # Stream response list
-            if "AnthropicMessageResponseBody" not in imported_models:
-                from .messages.response.response_body import (
-                    AnthropicMessageResponseBody,
-                )
-
-                imported_models["AnthropicMessageResponseBody"] = (
-                    AnthropicMessageResponseBody
-                )
-
-            # For streaming, we need to convert each chunk to OpenAI format
-            result = []
-            for item in response:
-                if "type" not in item:
-                    continue
-
-                if item.get("type") == "content_block_delta":
-                    if text := item.get("delta", {}).get(
-                        "type"
-                    ) == "text_delta" and item.get("delta", {}).get(
-                        "text", {}
-                    ):
-                        result.append(
-                            {
-                                "choices": [
-                                    {
-                                        "delta": {
-                                            "content": item["delta"]["text"],
-                                            "role": "assistant",
-                                        }
-                                    }
-                                ]
-                            }
-                        )
-                elif item.get("type") == "message_delta":
-                    # Include usage updates
-                    if "usage" in item:
-                        result.append(
-                            {
-                                "choices": [
-                                    {
-                                        "delta": {
-                                            "content": "",
-                                            "role": "assistant",
-                                        }
-                                    }
-                                ],
-                                "usage": item["usage"],
-                            }
-                        )
-                elif item.get("type") == "message_stop":
-                    # Final message with stop reason
-                    result.append(
-                        {
-                            "choices": [
-                                {
-                                    "delta": {
-                                        "content": "",
-                                        "role": "assistant",
-                                    },
-                                    "finish_reason": "stop",
-                                }
-                            ],
-                            "usage": item.get("usage", {}),
-                        }
-                    )
-
-            return result
-
-    raise ValueError(
-        "There is no standard response model for the provided request and response"
-    )

lionagi/integrations/anthropic_/api_endpoints/messages/request/message_models.py

@@ -1,14 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-
-class Message(BaseModel):
-    role: Literal["user", "assistant"] = Field(
-        description="The role of the message sender"
-    )
-    content: str = Field(description="The content of the message")

lionagi/integrations/anthropic_/api_endpoints/messages/request/request_body.py

@@ -1,74 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import Field, model_validator
-
-from ...data_models import AnthropicEndpointRequestBody
-from .message_models import Message
-
-
-class AnthropicMessageRequestBody(AnthropicEndpointRequestBody):
-    model: str = Field(
-        description="The model to use for generating the response"
-    )
-
-    messages: list[Message] = Field(
-        description="The messages to send to the model"
-    )
-
-    max_tokens: int = Field(
-        default=8000,  # Default to Anthropic's max model response tokens
-        description="The maximum number of tokens to generate before stopping",
-    )
-
-    metadata: dict | None = Field(
-        None, description="An object describing metadata about the request"
-    )
-
-    stop_sequences: list[str] | None = Field(
-        None,
-        description="Custom text sequences that will cause the model to stop generating",
-    )
-
-    stream: bool | None = Field(
-        False, description="Whether to stream the response back token by token"
-    )
-
-    system: str | None = Field(
-        None,
-        description="System prompt that helps define the behavior of the assistant",
-    )
-
-    temperature: float | None = Field(
-        None,
-        ge=0,
-        le=1,
-        description="Amount of randomness injected into the response",
-    )
-
-    top_k: int | None = Field(
-        None,
-        description="Number of most likely tokens to consider at each step",
-    )
-
-    top_p: float | None = Field(
-        None,
-        ge=0,
-        le=1,
-        description="Total probability mass of tokens to consider at each step",
-    )
-
-    @model_validator(mode="after")
-    def validate_messages(self):
-        if not self.messages:
-            raise ValueError("Messages list cannot be empty")
-
-        # Check for alternating user/assistant messages
-        for i in range(1, len(self.messages)):
-            if self.messages[i].role == self.messages[i - 1].role:
-                raise ValueError(
-                    "Messages must alternate between user and assistant roles"
-                )
-
-        return self

lionagi/integrations/anthropic_/api_endpoints/messages/response/content_models.py

@@ -1,32 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-
-class TextContent(BaseModel):
-    type: Literal["text"] = Field(description="Type of content block")
-    text: str = Field(description="The text content")
-
-
-class ToolUseContent(BaseModel):
-    type: Literal["tool_use"] = Field(description="Type of content block")
-    id: str = Field(description="Unique identifier for this tool use")
-    name: str = Field(description="Name of the tool being called")
-    input: dict = Field(description="Input parameters for the tool call")
-
-
-class ToolResultContent(BaseModel):
-    type: Literal["tool_result"] = Field(description="Type of content block")
-    tool_use_id: str = Field(
-        description="ID of the tool use this is a result for"
-    )
-    content: str = Field(
-        description="The result content from running the tool"
-    )
-
-
-ContentBlock = TextContent | ToolUseContent | ToolResultContent

lionagi/integrations/anthropic_/api_endpoints/messages/response/response_body.py

@@ -1,101 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Literal
-
-from pydantic import ConfigDict, Field, model_validator
-
-from ...data_models import AnthropicEndpointResponseBody
-from .content_models import ContentBlock
-from .usage_models import Usage
-
-
-class AnthropicMessageResponseBody(AnthropicEndpointResponseBody):
-    id: str = Field(description="Unique object identifier")
-
-    type: Literal[
-        "message",
-        "message_start",
-        "content_block_start",
-        "content_block_delta",
-        "content_block_stop",
-        "message_delta",
-        "message_stop",
-    ] = Field(description="Type of the response")
-
-    role: Literal["assistant"] | None = Field(
-        default=None,
-        description="Conversational role of the generated message. Always 'assistant' for non-stream responses",
-    )
-
-    content: list[ContentBlock] | None = Field(
-        default=None,
-        description="Content generated by the model",
-    )
-
-    model: str | None = Field(
-        default=None,
-        description="The model that handled the request",
-    )
-
-    stop_reason: (
-        Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None
-    ) = Field(
-        default=None,
-        description="""The reason that we stopped. May be:
-        "end_turn": the model reached a natural stopping point
-        "max_tokens": exceeded the requested max_tokens or model's maximum
-        "stop_sequence": one of the provided custom stop_sequences was generated
-        "tool_use": the model invoked one or more tools""",
-    )
-
-    stop_sequence: str | None = Field(
-        default=None,
-        description="Which custom stop sequence was generated, if any",
-    )
-
-    usage: Usage | None = Field(
-        default=None,
-        description="""Billing and rate-limit usage. Anthropic's API bills and
-        rate-limits by token counts, as tokens represent the underlying cost to our systems.""",
-    )
-
-    # Stream-specific fields
-    message: "AnthropicMessageResponseBody | None" = Field(
-        default=None,
-        description="Initial message object in stream response",
-    )
-
-    content_block: dict | None = Field(
-        default=None,
-        description="Content block information in stream response",
-    )
-
-    delta: dict | None = Field(
-        default=None,
-        description="Delta update in stream response",
-    )
-
-    message_id: str | None = Field(
-        default=None,
-        description="Message ID reference in stream response",
-    )
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    @model_validator(mode="after")
-    def validate_stream_fields(self):
-        # For stream responses, some fields are optional
-        if self.type != "message":
-            return self
-
-        # For regular message responses, validate required fields
-        if not self.role:
-            raise ValueError("role is required for message responses")
-        if self.content is None:
-            raise ValueError("content is required for message responses")
-        if not self.model:
-            raise ValueError("model is required for message responses")
-
-        return self

lionagi/integrations/anthropic_/api_endpoints/messages/response/usage_models.py

@@ -1,25 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import BaseModel, Field
-
-
-class Usage(BaseModel):
-    input_tokens: int = Field(
-        description="The number of input tokens which were used"
-    )
-
-    output_tokens: int = Field(
-        description="The number of output tokens which were used"
-    )
-
-    cache_creation_input_tokens: int | None = Field(
-        default=None,
-        description="The number of input tokens used to create the cache entry",
-    )
-
-    cache_read_input_tokens: int | None = Field(
-        default=None,
-        description="The number of input tokens read from the cache",
-    )