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

lionagi/integrations/openai_/api_endpoints/chat_completions/request/response_format.py

@@ -1,71 +0,0 @@
-import warnings
-from typing import Any, Dict, Literal, Optional
-
-from pydantic import BaseModel, Field, model_validator
-
-# Suppress the specific warning about field name shadowing
-warnings.filterwarnings(
-    "ignore",
-    message='Field name "schema" in "JSONSchema" '
-    'shadows an attribute in parent "BaseModel"',
-)
-
-
-class JSONSchema(BaseModel):
-    description: str | None = Field(
-        None,
-        description=(
-            "A description of what the response format is for, used by the "
-            "model to determine how to respond in the format."
-        ),
-    )
-
-    name: str = Field(
-        max_length=64,
-        pattern="^[a-zA-Z0-9_-]+$",
-        description=(
-            "The name of the response format. Must be a-z, A-Z, 0-9, or "
-            "contain underscores and dashes, with a maximum length of 64."
-        ),
-    )
-
-    schema: dict[str, Any] | None = Field(
-        None,
-        description="The schema for the response "
-        "format, described as a JSON Schema object.",
-    )
-
-    strict: bool | None = Field(
-        False,
-        description=(
-            "Whether to enable strict schema adherence when generating the "
-            "output. If set to true, the model will always follow the exact "
-            "schema defined in the `schema` field. Only a subset of JSON "
-            "Schema is supported when `strict` is `true`."
-        ),
-    )
-
-
-class ResponseFormat(BaseModel):
-    type: Literal["text", "json_object", "json_schema"] = Field(
-        description="The type of response format being defined."
-    )
-    json_schema: JSONSchema | None = Field(
-        None,
-        description=(
-            "The JSON schema to use when type is 'json_schema'. Required "
-            "when type is 'json_schema'."
-        ),
-    )
-
-    @model_validator(mode="after")
-    def validate_response_format(self) -> "ResponseFormat":
-        if self.type == "json_schema" and not self.json_schema:
-            raise ValueError(
-                "json_schema is required when type is 'json_schema'"
-            )
-        if self.type != "json_schema" and self.json_schema:
-            raise ValueError(
-                "json_schema should only be set when type is 'json_schema'"
-            )
-        return self

lionagi/integrations/openai_/api_endpoints/chat_completions/request/stream_options.py

@@ -1,14 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class StreamOptions(BaseModel):
-    include_usage: bool | None = Field(
-        None,
-        description=(
-            "If set, an additional chunk will be streamed before the "
-            "`data: [DONE]` message. The `usage` field on this chunk shows "
-            "the token usage statistics for the entire request, and the "
-            "`choices` field will always be an empty array. All other chunks "
-            "will also include a `usage` field, but with a null value."
-        ),
-    )

lionagi/integrations/openai_/api_endpoints/chat_completions/request/tool_choice_models.py

@@ -1,17 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-
-class Function(BaseModel):
-    name: str = Field(description="The name of the function to call.")
-
-
-class ToolChoice(BaseModel):
-    type: Literal["function"] = Field(
-        description="The type of the tool. Currently,"
-        " only function is supported."
-    )
-    function: Function = Field(
-        description="Specifies the function to be called."
-    )

lionagi/integrations/openai_/api_endpoints/chat_completions/request/tool_models.py

@@ -1,54 +0,0 @@
-from typing import Any, Dict, List, Literal, Optional
-
-from pydantic import BaseModel, Field
-
-
-class FunctionParameters(BaseModel):
-    type: Literal["object"] = "object"
-    properties: dict[str, dict[str, Any]]
-    required: list[str] | None = None
-
-
-class Function(BaseModel):
-    description: str | None = Field(
-        None,
-        description=(
-            "A description of what the function does, used by the model to "
-            "choose when and how to call the function."
-        ),
-    )
-
-    name: str = Field(
-        max_length=64,
-        pattern="^[a-zA-Z0-9_-]+$",
-        description=(
-            "The name of the function to be called. Must be a-z, A-Z, 0-9, "
-            "or contain underscores and dashes, with a maximum length of 64."
-        ),
-    )
-
-    parameters: FunctionParameters | None = Field(
-        None,
-        description=(
-            "The parameters the functions accepts, described as a JSON Schema "
-            "object. See the guide for examples, and the JSON Schema "
-            "reference for documentation about the format."
-        ),
-    )
-
-    strict: bool | None = Field(
-        False,
-        description="Whether to enable strict schema"
-        " adherence when generating the function call. "
-        "If set to true, the model will follow the exact"
-        " schema defined in the parameters field. "
-        "Only a subset of JSON Schema is supported when strict is true.",
-    )
-
-
-class Tool(BaseModel):
-    type: Literal["function"] = Field(
-        description="The type of the tool. Currently,"
-        " only function is supported."
-    )
-    function: Function = Field(description="The function definition.")

lionagi/integrations/openai_/api_endpoints/chat_completions/request/types.py

@@ -1,18 +0,0 @@
-from enum import Enum
-
-
-class Detail(str, Enum):
-    AUTO = "auto"
-    LOW = "low"
-    HIGH = "high"
-
-
-class ServiceTier(str, Enum):
-    AUTO = "auto"
-    DEFAULT = "default"
-
-
-class ToolChoice(str, Enum):
-    NONE = "none"
-    AUTO = "auto"
-    REQUIRED = "required"

lionagi/integrations/openai_/api_endpoints/chat_completions/response/choice_models.py

@@ -1,62 +0,0 @@
-from pydantic import BaseModel, ConfigDict, Field
-
-from .log_prob_models import LogProbs
-from .message_models import Message
-from .types import FinishReason
-
-
-class Choice(BaseModel):
-    finish_reason: FinishReason = Field(
-        description=(
-            "The reason the model stopped generating tokens. This will be "
-            "stop if the model hit a natural stop point or a provided stop "
-            "sequence, length if the maximum number of tokens specified in "
-            "the request was reached, content_filter if content was omitted "
-            "due to a flag from our content filters, tool_calls if the model "
-            "called a tool, or function_call (deprecated) if the model "
-            "called a function."
-        )
-    )
-
-    index: int = Field(
-        description="The index of the choice in the list of choices."
-    )
-
-    message: Message = Field(
-        description="A chat completion message generated by the model."
-    )
-
-    logprobs: LogProbs | None = Field(
-        None, description="Log probability information for the choice."
-    )
-
-    model_config = ConfigDict(use_enum_values=True)
-
-
-class ChunkChoice(BaseModel):
-    delta: Message = Field(
-        description="A chat completion delta generated"
-        " by streamed model responses."
-    )
-
-    logprobs: LogProbs | None = Field(
-        description="Log probability information for the choice."
-    )
-
-    finish_reason: FinishReason | None = Field(
-        description=(
-            "The reason the model stopped generating tokens. This will be "
-            "stop if the model hit a natural stop point or a provided stop "
-            "sequence, length if the maximum number of tokens specified in "
-            "the request was reached, content_filter if content was omitted "
-            "due to a flag from our content filters, tool_calls if the model "
-            "called a tool, or function_call (deprecated) if the model "
-            "called a function."
-        )
-    )
-
-    index: int = Field(
-        description="The index of the choice in the list of choices."
-    )
-
-    model_config = ConfigDict(use_enum_values=True)

lionagi/integrations/openai_/api_endpoints/chat_completions/response/function_models.py

@@ -1,16 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-
-class Function(BaseModel):
-    name: str = Field(description="The name of the function to call.")
-    arguments: str = Field(
-        description="The arguments to pass to the function."
-    )
-
-
-class ToolCall(BaseModel):
-    id: str = Field(description="The ID of the tool call.")
-    type: Literal["function"] = Field(description="The type of the tool call.")
-    function: Function = Field(description="The function call details.")

lionagi/integrations/openai_/api_endpoints/chat_completions/response/log_prob_models.py

@@ -1,47 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel, Field
-
-
-class TokenLogProb(BaseModel):
-    token: str = Field(description="The token.")
-    logprob: float = Field(
-        description=(
-            "The log probability of this token, if it is within the top 20 "
-            "most likely tokens. Otherwise, the value -9999.0 is used to "
-            "signify that the token is very unlikely."
-        )
-    )
-    bytes: list[int] | None = Field(
-        None,
-        description=(
-            "A list of integers representing the UTF-8 bytes representation "
-            "of the token. Useful in instances where characters are "
-            "represented by multiple tokens and their byte representations "
-            "must be combined to generate the correct text representation. "
-            "Can be null if there is no bytes representation for the token."
-        ),
-    )
-
-
-class LogProbContent(TokenLogProb):
-    top_logprobs: list[TokenLogProb] = Field(
-        description=(
-            "List of the most likely tokens and their log probability, at "
-            "this token position. In rare cases, there may be fewer than the "
-            "number of requested top_logprobs returned."
-        )
-    )
-
-
-class LogProbs(BaseModel):
-    content: list[LogProbContent] | None = Field(
-        None,
-        description="A list of message content "
-        "tokens with log probability information.",
-    )
-    refusal: list[LogProbContent] | None = Field(
-        None,
-        description="A list of message refusal "
-        "tokens with log probability information.",
-    )

lionagi/integrations/openai_/api_endpoints/chat_completions/response/message_models.py

@@ -1,25 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel, Field
-
-from .function_models import ToolCall
-
-
-class Message(BaseModel):
-    content: str | None = Field(
-        None, description="The contents of the message."
-    )
-
-    refusal: str | None = Field(
-        None, description="The refusal message generated by the model."
-    )
-
-    tool_calls: list[ToolCall] | None = Field(
-        None,
-        description="The tool calls generated by the model, "
-        "such as function calls.",
-    )
-
-    role: str | None = Field(
-        None, description="The role of the author of this message."
-    )

lionagi/integrations/openai_/api_endpoints/chat_completions/response/response_body.py

@@ -1,99 +0,0 @@
-from typing import List, Literal, Optional
-
-from pydantic import Field
-
-from ...data_models import OpenAIEndpointResponseBody
-from .choice_models import Choice, ChunkChoice
-from .usage_models import Usage
-
-
-class OpenAIChatCompletionResponseBody(OpenAIEndpointResponseBody):
-    id: str = Field(description="A unique identifier for the chat completion.")
-
-    choices: list[Choice] = Field(
-        description=(
-            "A list of chat completion choices. Can be more than one if n "
-            "is greater than 1."
-        )
-    )
-
-    created: int = Field(
-        description=(
-            "The Unix timestamp (in seconds) of when the chat completion "
-            "was created."
-        )
-    )
-
-    model: str = Field(description="The model used for the chat completion.")
-
-    service_tier: str | None = Field(
-        None,
-        description=(
-            "The service tier used for processing the request. This field is "
-            "only included if the service_tier parameter is specified in the "
-            "request."
-        ),
-    )
-
-    system_fingerprint: str = Field(
-        description=(
-            "This fingerprint represents the backend configuration that the "
-            "model runs with. Can be used in conjunction with the seed "
-            "request parameter to understand when backend changes have been "
-            "made that might impact determinism."
-        )
-    )
-
-    object: Literal["chat.completion"] = Field(
-        description="The object type, which is always chat.completion."
-    )
-
-    usage: Usage = Field(
-        description="Usage statistics for the completion request."
-    )
-
-
-class OpenAIChatCompletionChunkResponseBody(OpenAIEndpointResponseBody):
-    id: str = Field(description="A unique identifier for the chat completion.")
-
-    choices: list[ChunkChoice] = Field(
-        description=(
-            "A list of chat completion choices. Can be more than one if n "
-            "is greater than 1."
-        )
-    )
-
-    created: int = Field(
-        description=(
-            "The Unix timestamp (in seconds) of when the chat completion "
-            "was created."
-        )
-    )
-
-    model: str = Field(description="The model used for the chat completion.")
-
-    service_tier: str | None = Field(
-        None,
-        description=(
-            "The service tier used for processing the request. This field is "
-            "only included if the service_tier parameter is specified in the "
-            "request."
-        ),
-    )
-
-    system_fingerprint: str = Field(
-        description=(
-            "This fingerprint represents the backend configuration that the "
-            "model runs with. Can be used in conjunction with the seed "
-            "request parameter to understand when backend changes have been "
-            "made that might impact determinism."
-        )
-    )
-
-    object: Literal["chat.completion.chunk"] = Field(
-        description="The object type, which is always chat.completion."
-    )
-
-    usage: Usage | None = Field(
-        None, description="Usage statistics for the completion request."
-    )

lionagi/integrations/openai_/api_endpoints/chat_completions/response/types.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class FinishReason(str, Enum):
-    STOP = "stop"
-    LENGTH = "length"
-    CONTENT_FILTER = "content_filter"
-    TOOL_CALLS = "tool_calls"

lionagi/integrations/openai_/api_endpoints/chat_completions/response/usage_models.py

@@ -1,24 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class CompletionTokensDetails(BaseModel):
-    reasoning_tokens: int = Field(
-        description="Tokens generated by the model for reasoning."
-    )
-
-
-class Usage(BaseModel):
-    completion_tokens: int = Field(
-        description="Number of tokens in the generated completion."
-    )
-
-    prompt_tokens: int = Field(description="Number of tokens in the prompt.")
-
-    total_tokens: int = Field(
-        description="Total number of tokens used in the"
-        " request (prompt + completion)"
-    )
-
-    completion_tokens_details: CompletionTokensDetails = Field(
-        description="Breakdown of tokens used in a completion."
-    )

lionagi/integrations/openai_/api_endpoints/chat_completions/util.py

@@ -1,46 +0,0 @@
-from .request.request_body import OpenAIChatCompletionRequestBody
-
-
-def get_text_messages(request_body: OpenAIChatCompletionRequestBody):
-    messages_list = request_body.model_dump(exclude_unset=True).get("messages")
-    parsed_str = "["
-
-    for msg in messages_list:
-        role = msg.get("role", "")
-        content = msg.get("content", "")
-
-        if isinstance(
-            content, list
-        ):  # Check if content is a list (second example)
-            content_str = []
-            for sub_content in content:
-                if sub_content.get("type") == "text":
-                    content_str.append(f'{sub_content.get("text", "")}')
-            content = " ".join(
-                content_str
-            )  # Combine all sub_content items into a single string
-        parsed_str += f"role: {role} content: {content} "
-
-    parsed_str = parsed_str.strip()  # Remove trailing space
-    parsed_str += "]"
-
-    return parsed_str
-
-
-def get_images(request_body: OpenAIChatCompletionRequestBody):
-    messages_list = request_body.model_dump(exclude_unset=True).get("messages")
-    image_urls = []
-
-    for msg in messages_list:
-        content = msg.get("content", "")
-
-        if isinstance(
-            content, list
-        ):  # Check if content is a list (second example)
-            for sub_content in content:
-                if sub_content.get("type") == "image_url":
-                    image_url = sub_content.get("image_url")
-                    url = image_url.get("url")
-                    detail = image_url.get("detail", "auto")
-                    image_urls.append((url, detail))
-    return image_urls

lionagi/integrations/openai_/api_endpoints/data_models.py

@@ -1,23 +0,0 @@
-from pydantic import BaseModel, ConfigDict
-
-
-class OpenAIEndpointRequestBody(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid", use_enum_values=True, validate_assignment=True
-    )
-
-
-class OpenAIEndpointResponseBody(BaseModel):
-    model_config = ConfigDict(use_enum_values=True, validate_assignment=True)
-
-
-class OpenAIEndpointQueryParam(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid", use_enum_values=True, validate_assignment=True
-    )
-
-
-class OpenAIEndpointPathParam(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid", use_enum_values=True, validate_assignment=True
-    )

lionagi/integrations/openai_/api_endpoints/embeddings/__init__.py

@@ -1,3 +0,0 @@
-from .request_body import OpenAIEmbeddingRequestBody
-
-__all__ = [OpenAIEmbeddingRequestBody]

lionagi/integrations/openai_/api_endpoints/embeddings/request_body.py

@@ -1,79 +0,0 @@
-from typing import List, Literal, Optional, Union
-
-from pydantic import ConfigDict, Field, model_validator
-
-from ..data_models import OpenAIEndpointRequestBody
-
-InputType = Union[str, list[str], list[int], list[list[int]]]
-EncodingFormat = Literal["float", "base64"]
-
-
-class OpenAIEmbeddingRequestBody(OpenAIEndpointRequestBody):
-    input: InputType = Field(
-        description=(
-            "Input text to embed, encoded as a string or array of tokens. "
-            "To embed multiple inputs in a single request, pass an array of "
-            "strings or array of token arrays. The input must not exceed "
-            "the max input tokens for the model (8192 tokens for "
-            "text-embedding-ada-002), cannot be an empty string, and any "
-            "array must be 2048 dimensions or less."
-        ),
-    )
-
-    model: str = Field(
-        description=(
-            "ID of the model to use. You can use the List models API to see "
-            "all of your available models, or see our Model overview for "
-            "descriptions of them."
-        ),
-    )
-
-    encoding_format: EncodingFormat | None = Field(
-        "float",
-        description=(
-            "The format to return the embeddings in. Can be either `float` "
-            "or `base64`."
-        ),
-    )
-
-    dimensions: int | None = Field(
-        None,
-        description=(
-            "The number of dimensions the resulting output embeddings "
-            "should have. Only supported in `text-embedding-3` and later "
-            "models."
-        ),
-    )
-
-    user: str | None = Field(
-        None,
-        description=(
-            "A unique identifier representing your end-user, which can help "
-            "OpenAI to monitor and detect abuse."
-        ),
-    )
-
-    @model_validator(mode="after")
-    def validate_input(self) -> "OpenAIEmbeddingRequestBody":
-        if isinstance(self.input, str) and self.input.strip() == "":
-            raise ValueError("Input cannot be an empty string.")
-        if isinstance(self.input, list):
-            if len(self.input) == 0:
-                raise ValueError("Input array cannot be empty.")
-            if isinstance(self.input[0], list) and len(self.input) > 2048:
-                raise ValueError(
-                    "Input array must be 2048 dimensions or less."
-                )
-        return self
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "example": {
-                "input": "The food was delicious and the waiter...",
-                "model": "text-embedding-ada-002",
-                "encoding_format": "float",
-                "dimensions": None,
-                "user": "user123",
-            }
-        }
-    )