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

lionagi/integrations/openai_/api_endpoints/batch/batch_models.py

@@ -1,146 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ..data_models import OpenAIEndpointResponseBody
-
-
-class Data(BaseModel):
-    code: str = Field(description="An error code identifying the error type.")
-
-    message: str = Field(
-        description="A human-readable message providing more details"
-        " about the error."
-    )
-
-    param: str | None = Field(
-        None,
-        description="The name of the parameter that caused the "
-        "error, if applicable.",
-    )
-
-    line: int | None = Field(
-        None,
-        description="The line number of the input file where "
-        "the error occurred, if applicable.",
-    )
-
-
-class Error(BaseModel):
-    object: Literal["list"] = Field(
-        description="The object type, which is always 'list'."
-    )
-
-    data: Data = Field(description="A list of error data.")
-
-
-class RequestCounts(BaseModel):
-    total: int = Field(description="Total number of requests in the batch.")
-
-    completed: int = Field(
-        description="Number of requests that have been completed successfully."
-    )
-
-    failed: int = Field(description="Number of requests that have failed.")
-
-
-class OpenAIBatchResponseBody(OpenAIEndpointResponseBody):
-    id: str = Field(description="A unique identifier for the batch.")
-
-    object: Literal["batch"] = Field(
-        description="The object type, which is always 'batch'."
-    )
-
-    endpoint: str = Field(description="The API endpoint used for this batch.")
-
-    errors: Error | None = Field(
-        None, description="Errors encountered during batch processing."
-    )
-
-    input_file_id: str | None = Field(
-        None, description="The ID of the input file for the batch."
-    )
-
-    completion_window: str | None = Field(
-        None,
-        description="The time frame within which the batch "
-        "should be processed.",
-    )
-
-    status: str = Field(description="The current status of the batch.")
-
-    output_file_id: str | None = Field(
-        None,
-        description="The ID of the file containing the outputs of "
-        "successfully executed requests.",
-    )
-
-    error_file_id: str | None = Field(
-        None,
-        description="The ID of the file containing the outputs "
-        "of requests with errors.",
-    )
-
-    created_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for when "
-        "the batch was created.",
-    )
-
-    in_progress_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for when the"
-        " batch started processing.",
-    )
-
-    expires_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for"
-        " when the batch will expire.",
-    )
-
-    finalizing_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for"
-        " when the batch started finalizing.",
-    )
-
-    completed_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for"
-        " when the batch was completed.",
-    )
-
-    failed_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for"
-        " when the batch failed.",
-    )
-
-    expired_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for"
-        " when the batch expired.",
-    )
-
-    cancelling_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for"
-        " when the batch started cancelling.",
-    )
-
-    cancelled_at: int | None = Field(
-        None,
-        description="The Unix timestamp (in seconds) for"
-        " when the batch was cancelled.",
-    )
-
-    request_counts: RequestCounts = Field(
-        description="The request counts for different statuses"
-        " within the batch."
-    )
-
-    metadata: dict | None = Field(
-        description="Set of 16 key-value pairs that can be"
-        " attached to an object."
-    )

lionagi/integrations/openai_/api_endpoints/batch/cancel_batch.py

@@ -1,7 +0,0 @@
-from pydantic import Field
-
-from ..data_models import OpenAIEndpointPathParam
-
-
-class OpenAICancelBatchPathParam(OpenAIEndpointPathParam):
-    batch_id: str = Field(description="The ID of the batch to cancel.")

lionagi/integrations/openai_/api_endpoints/batch/create_batch.py

@@ -1,26 +0,0 @@
-from typing import Literal, Optional
-
-from pydantic import Field
-
-from ..data_models import OpenAIEndpointRequestBody
-from .types import Endpoint
-
-
-class OpenAIBatchRequestBody(OpenAIEndpointRequestBody):
-    input_file_id: str = Field(
-        description="The ID of an uploaded file that contains requests"
-        " for the new batch."
-    )
-
-    endpoint: Endpoint = Field(
-        description="The endpoint to be used for all requests in the batch."
-    )
-
-    completion_window: Literal["24h"] = Field(
-        description="The time frame within which the batch"
-        " should be processed."
-    )
-
-    metadata: dict | None = Field(
-        None, description="Optional custom metadata for the batch."
-    )

lionagi/integrations/openai_/api_endpoints/batch/list_batch.py

@@ -1,37 +0,0 @@
-from typing import List, Literal, Optional
-
-from pydantic import Field
-
-from ..data_models import OpenAIEndpointQueryParam, OpenAIEndpointResponseBody
-from .batch_models import OpenAIBatchResponseBody
-
-
-class OpenAIListBatchQueryParam(OpenAIEndpointQueryParam):
-    after: str | None = Field(
-        None, description="A cursor for use in pagination. "
-    )
-
-    limit: int | None = Field(
-        default=20,
-        description="A limit on the number of objects to be returned. "
-        "Limit can range between 1 and 100, and the default is 20.",
-    )
-
-
-class OpenAIListBatchResponseBody(OpenAIEndpointResponseBody):
-    data: list[OpenAIBatchResponseBody] = Field(
-        description="The list of batch objects."
-    )
-
-    object: Literal["list"] = Field(
-        description='The object type, which is always "list".'
-    )
-
-    first_id: str = Field(description="The first object id in the list")
-
-    last_id: str = Field(description="The last object id in the list")
-
-    has_more: bool = Field(
-        description="Whether there are more results "
-        "available after this batch."
-    )

lionagi/integrations/openai_/api_endpoints/batch/request_object_models.py

@@ -1,65 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel, Field, SerializeAsAny
-
-from ..data_models import OpenAIEndpointRequestBody
-from .types import Endpoint
-
-
-class Response(BaseModel):
-    status_code: int = Field(
-        description="The HTTP status code of the response."
-    )
-
-    request_id: str = Field(
-        description="An unique identifier for the OpenAI API request. "
-        "Please include this request ID when contacting support."
-    )
-
-    body: dict = Field(description="The JSON body of the response")
-
-
-class Error(BaseModel):
-    code: str = Field(description="A machine-readable error code.")
-
-    message: str = Field(description="A human-readable error message.")
-
-
-class OpenAIBatchRequestInputObject(BaseModel):
-    custom_id: str = Field(
-        description="A developer-provided per-request id "
-        "that will be used to match outputs to inputs. "
-        "Must be unique for each request in a batch."
-    )
-
-    method: Literal["POST"] = Field(
-        description="The HTTP method to be used for the "
-        "request. Currently only POST is supported."
-    )
-
-    url: Endpoint = Field(
-        description="The OpenAI API relative URL to be"
-        " used for the request."
-    )
-
-    body: SerializeAsAny[OpenAIEndpointRequestBody] = Field(
-        description="the parameters for the underlying endpoint."
-    )
-
-
-class OpenAIBatchRequestOutputObject(BaseModel):
-    id: str = Field(description="The output object id.")
-
-    custom_id: str = Field(
-        description="A developer-provided per-request id"
-        " that will be used to match outputs to inputs."
-    )
-
-    response: Response | None = Field(
-        description="The endpoint response body."
-    )
-
-    error: Error | None = Field(
-        description="For requests that failed with a non-HTTP error, "
-        "this will contain more information on the cause of the failure."
-    )

lionagi/integrations/openai_/api_endpoints/batch/retrieve_batch.py

@@ -1,7 +0,0 @@
-from pydantic import Field
-
-from ..data_models import OpenAIEndpointPathParam
-
-
-class OpenAIRetrieveBatchPathParam(OpenAIEndpointPathParam):
-    batch_id: str = Field(description="The ID of the batch to retrieve.")

lionagi/integrations/openai_/api_endpoints/batch/types.py

@@ -1,4 +0,0 @@
-from typing import Literal
-
-# Endpoint literals
-Endpoint = Literal["/v1/chat/completions", "/v1/embeddings", "/v1/completions"]

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

@@ -1 +0,0 @@
-from .request import *  # noqa

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

@@ -1,39 +0,0 @@
-from .message_models import AssistantMessage
-from .message_models import Function as MessageFunction
-from .message_models import (
-    ImageContentPart,
-    ImageURL,
-    SystemMessage,
-    TextContentPart,
-    ToolCall,
-    ToolMessage,
-    UserMessage,
-)
-from .request_body import OpenAIChatCompletionRequestBody
-from .response_format import JSONSchema, ResponseFormat
-from .stream_options import StreamOptions
-from .tool_choice_models import Function as ToolChoiceFunction
-from .tool_choice_models import ToolChoice
-from .tool_models import Function as ToolFunction
-from .tool_models import FunctionParameters, Tool
-
-__all__ = [
-    "OpenAIChatCompletionRequestBody",
-    "SystemMessage",
-    "UserMessage",
-    "AssistantMessage",
-    "ToolMessage",
-    "TextContentPart",
-    "ImageContentPart",
-    "ImageURL",
-    "ToolCall",
-    "MessageFunction",
-    "ResponseFormat",
-    "JSONSchema",
-    "StreamOptions",
-    "Tool",
-    "ToolFunction",
-    "FunctionParameters",
-    "ToolChoice",
-    "ToolChoiceFunction",
-]

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

@@ -1,121 +0,0 @@
-from typing import List, Literal, Optional, TypeAlias
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-from .types import Detail
-
-
-class TextContentPart(BaseModel):
-    type: Literal["text"] = Field(description="The type of the content part.")
-    text: str = Field(description="The text content.")
-
-
-class ImageURL(BaseModel):
-    url: str = Field(description="The URL of the image.")
-    detail: Detail = Field(
-        "auto", description="The detail level of the image."
-    )
-    model_config = ConfigDict(use_enum_values=True)
-
-
-class ImageContentPart(BaseModel):
-    type: Literal["image_url"] = Field(
-        description="The type of the content part."
-    )
-    image_url: ImageURL = Field(description="The image URL and detail level.")
-
-
-ContentPart: TypeAlias = TextContentPart | ImageContentPart
-
-
-class Function(BaseModel):
-    name: str = Field(description="The name of the function to call.")
-    arguments: str = Field(
-        description="The arguments to call the function with, as JSON."
-    )
-
-
-class ToolCall(BaseModel):
-    id: str = Field(description="The ID of the tool call.")
-    type: Literal["function"] = Field(
-        description="The type of the tool. Only 'function' is supported."
-    )
-    function: Function = Field(
-        description="The function that the model called."
-    )
-
-
-class SystemMessage(BaseModel):
-    role: Literal["system"]
-    content: str = Field(description="The content of the system message.")
-
-    name: str | None = Field(
-        None,
-        description="An optional name for the participant."
-        " Provides the model information "
-        "to differentiate between participants of the same role.",
-    )
-
-
-class UserMessage(BaseModel):
-    role: Literal["user"]
-    content: str | list[ContentPart] = Field(
-        description="The content of the user message"
-    )
-
-    name: str | None = Field(
-        None,
-        description="An optional name for the participant."
-        " Provides the model information "
-        "to differentiate between participants of the same role.",
-    )
-
-
-class AssistantMessage(BaseModel):
-    role: Literal["assistant"]
-    content: str | None = Field(
-        None,
-        description="The contents of the assistant message."
-        " Required unless tool_calls is specified.",
-    )
-
-    refusal: str | None = Field(
-        None, description="The refusal message by the assistant."
-    )
-
-    name: str | None = Field(
-        None,
-        description="An optional name for the participant."
-        " Provides the model information "
-        "to differentiate between participants of the same role.",
-    )
-
-    tool_calls: list[ToolCall] | None = Field(
-        None,
-        description="The tool calls generated by the model,"
-        " such as function calls.",
-    )
-
-    @model_validator(mode="after")
-    def validate_content(self):
-        if not self.content and not self.tool_calls:
-            raise ValueError(
-                "Assistant messages require content or tool_calls"
-            )
-        return self
-
-
-class ToolMessage(BaseModel):
-    role: Literal["tool"]
-    content: str | list = Field(
-        description="The contents of the tool message."
-    )
-
-    tool_calls_id: str = Field(
-        description="Tool call that this message is responding to."
-    )
-
-
-Message: TypeAlias = (
-    SystemMessage | UserMessage | AssistantMessage | ToolMessage
-)

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

@@ -1,221 +0,0 @@
-from typing import Dict, List, Optional
-
-from pydantic import Field, SerializeAsAny, model_validator
-
-from ...data_models import OpenAIEndpointRequestBody
-from .message_models import Message
-from .response_format import ResponseFormat
-from .stream_options import StreamOptions
-from .tool_choice_models import ToolChoice as ToolChoiceObj
-from .tool_models import Tool
-from .types import ServiceTier
-from .types import ToolChoice as ToolChoiceStr
-
-
-class OpenAIChatCompletionRequestBody(OpenAIEndpointRequestBody):
-    messages: SerializeAsAny[list[Message]] = Field(
-        description="A list of messages comprising the conversation so far."
-    )
-
-    model: str = Field(description="ID of the model to use.")
-
-    frequency_penalty: float | None = Field(
-        0,
-        ge=-2.0,
-        le=2.0,
-        description=(
-            "Number between -2.0 and 2.0. Positive values penalize new tokens "
-            "based on their existing frequency in the text so far, decreasing "
-            "the model's likelihood to repeat the same line verbatim."
-        ),
-    )
-
-    logit_bias: dict[str, float] | None = Field(
-        None,
-        description=(
-            "Modify the likelihood of specified tokens appearing in the "
-            "completion. Accepts a JSON object that maps tokens (specified by "
-            "their token ID in the tokenizer) to an associated "
-            "bias value from -100 to 100."
-        ),
-    )
-
-    logprobs: bool | None = Field(
-        False,
-        description=(
-            "Whether to return log probabilities of the output tokens or not. "
-            "If true, returns the log probabilities of each output token "
-            "returned in the content of message."
-        ),
-    )
-
-    top_logprobs: int | None = Field(
-        None,
-        ge=0,
-        le=20,
-        description=(
-            "An integer between 0 and 20 specifying the number of most likely "
-            "tokens to return at each token position, each with an associated "
-            "log probability. logprobs must be true if this parameter "
-            "is used."
-        ),
-    )
-
-    max_completion_tokens: int | None = Field(
-        None,
-        description=(
-            "The maximum number of tokens that can be generated in the chat "
-            "completion. The total length of input tokens and generated "
-            "tokens is limited by the model's context length."
-        ),
-    )
-
-    n: int | None = Field(
-        1,
-        ge=1,
-        description=(
-            "How many chat completion choices to generate for each input "
-            "message. Note that you will be charged based on the number of "
-            "generated tokens across all of the choices. Keep n as 1 to "
-            "minimize costs."
-        ),
-    )
-
-    presence_penalty: float | None = Field(
-        0,
-        ge=-2.0,
-        le=2.0,
-        description=(
-            "Number between -2.0 and 2.0. Positive values penalize new tokens "
-            "based on whether they appear in the text so far, increasing the "
-            "model's likelihood to talk about new topics."
-        ),
-    )
-
-    response_format: ResponseFormat | None = Field(
-        None,
-        description=(
-            "An object specifying the format that the model must output. "
-            "Compatible with GPT-4o, GPT-4o mini, GPT-4 Turbo and all GPT-3.5 "
-            "Turbo models newer than gpt-3.5-turbo-1106. Setting to "
-            "{ 'type': 'json_schema', 'json_schema': {...} } enables "
-            "Structured Outputs. Setting to { 'type': 'json_object' } enables "
-            "JSON mode. Important: when using JSON mode, you must also "
-            "instruct the model to produce JSON via a system or user message."
-        ),
-    )
-
-    seed: int | None = Field(
-        None,
-        description=(
-            "This feature is in Beta. If specified, our system will make a "
-            "best effort to sample deterministically, such that repeated "
-            "requests with the same seed and parameters should return the "
-            "same result."
-        ),
-    )
-
-    service_tier: ServiceTier | None = Field(
-        None,
-        description=(
-            "Specifies the latency tier to use for processing the request. "
-            "This parameter is relevant for customers subscribed to the scale "
-            "tier service."
-        ),
-    )
-
-    stop: str | list[str] | None = Field(
-        None,
-        max_items=4,
-        description=(
-            "Up to 4 sequences where the API will stop generating further "
-            "tokens."
-        ),
-    )
-
-    stream: bool | None = Field(
-        False,
-        description=(
-            "If set, partial message deltas will be sent, like in ChatGPT. "
-            "Tokens will be sent as data-only server-sent events as they "
-            "become available, with the stream terminated by a data: [DONE] "
-            "message."
-        ),
-    )
-
-    stream_options: StreamOptions | None = Field(
-        None,
-        description=(
-            "Options for streaming response. Only set this when you set "
-            "stream: true."
-        ),
-    )
-
-    temperature: float | None = Field(
-        1.0,
-        ge=0,
-        le=2,
-        description=(
-            "What sampling temperature to use, between 0 and 2. Higher values "
-            "like 0.8 will make the output more random, while lower values "
-            "like 0.2 will make it more focused and deterministic."
-        ),
-    )
-
-    top_p: float | None = Field(
-        1.0,
-        ge=0,
-        le=1,
-        description=(
-            "An alternative to sampling with temperature, called nucleus "
-            "sampling, where the model considers the results of the tokens "
-            "with top_p probability mass. So 0.1 means only the tokens "
-            "comprising the top 10% probability mass are considered."
-        ),
-    )
-
-    tools: list[Tool] | None = Field(
-        None,
-        max_items=128,
-        description=(
-            "A list of tools the model may call. Currently, only functions "
-            "are supported as a tool. Use this to provide a list of functions "
-            "the model may generate JSON inputs for."
-        ),
-    )
-
-    tool_choice: ToolChoiceStr | ToolChoiceObj | None = Field(
-        None,
-        description=(
-            "Controls which (if any) tool is called by the model. 'none' "
-            "means the model will not call a tool and instead generates a "
-            "message. 'auto' means the model can pick between generating a "
-            "message or calling a tool. 'required' means the model must call "
-            "a tool."
-        ),
-    )
-
-    parallel_tool_calls: bool | None = Field(
-        True,
-        decription="Whether to enable parallel "
-        "function calling during tool use.",
-    )
-
-    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_request(self) -> "OpenAIChatCompletionRequestBody":
-        if self.tools:
-            self.model_fields["tool_choice"].default = "auto"
-        else:
-            self.model_fields["tool_choice"].default = "none"
-
-        if self.top_logprobs is not None and not self.logprobs:
-            raise ValueError("logprobs must be true when top_logprobs is set")
-        return self