lionagi 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

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

@@ -0,0 +1,9 @@
+from .speech_models import OpenAISpeechRequestBody
+from .transcription_models import OpenAITranscriptionRequestBody
+from .translation_models import OpenAITranslationRequestBody
+
+__all__ = [
+    "OpenAISpeechRequestBody",
+    "OpenAITranscriptionRequestBody",
+    "OpenAITranslationRequestBody",
+]

lionagi/integrations/openai_/api_endpoints/audio/speech_models.py

@@ -0,0 +1,34 @@
+from pydantic import ConfigDict, Field
+
+from ..data_models import OpenAIEndpointRequestBody
+from .types import AudioFormat, TTSModel, Voice
+
+
+class OpenAISpeechRequestBody(OpenAIEndpointRequestBody):
+    model: TTSModel = Field(description="The TTS model to use")
+    input: str = Field(
+        description="The text to generate audio for", max_length=4096
+    )
+    voice: Voice = Field(
+        description="The voice to use when generating the audio"
+    )
+    response_format: AudioFormat = Field(
+        default=AudioFormat.MP3,
+        description="The format of the generated audio",
+    )
+    speed: float = Field(
+        default=1.0,
+        ge=0.25,
+        le=4.0,
+        description="The speed of the generated audio",
+    )
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "model": "tts-1",
+                "input": "The quick brown fox jumped over the lazy dog.",
+                "voice": "alloy",
+            }
+        }
+    )

lionagi/integrations/openai_/api_endpoints/audio/transcription_models.py

@@ -0,0 +1,136 @@
+from typing import IO, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from ..data_models import OpenAIEndpointRequestBody, OpenAIEndpointResponseBody
+from .types import (
+    TimestampGranularity,
+    TranscriptionResponseFormat,
+    WhisperModel,
+)
+
+
+class OpenAITranscriptionRequestBody(OpenAIEndpointRequestBody):
+    file: str | IO = Field(description="The audio file to transcribe")
+    model: WhisperModel = Field(
+        description="The model to use for transcription"
+    )
+    language: str | None = Field(
+        None, description="The language of the input audio (ISO-639-1 format)"
+    )
+    prompt: str | None = Field(
+        None,
+        description="An optional text to guide the model's style or"
+        " continue a previous audio segment",
+    )
+    response_format: TranscriptionResponseFormat = Field(
+        default="json",
+        description="The format of the transcript output",
+    )
+    temperature: float = Field(
+        default=0, ge=0, le=1, description="The sampling temperature"
+    )
+    timestamp_granularities: list[TimestampGranularity] | None = Field(
+        default=["segment"],
+        description="The timestamp granularities to populate "
+        "for this transcription",
+    )
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @field_validator("file")
+    @classmethod
+    def get_file_object(cls, value):
+        if isinstance(value, str):
+            value = open(value, "rb")
+        return value
+
+    def __del__(self):
+        # Ensure the file is closed when the object is destroyed
+        file_obj = self.__dict__.get("file")
+        if file_obj and not file_obj.closed:
+            file_obj.close()
+
+
+class OpenAITranscriptionResponseBody(OpenAIEndpointResponseBody):
+    text: str = Field(description="The transcribed text")
+
+
+class Word(BaseModel):
+    word: str
+    start: float
+    end: float
+
+
+class Segment(BaseModel):
+    id: int
+    seek: int
+    start: float
+    end: float
+    text: str
+    tokens: list[int]
+    temperature: float
+    avg_logprob: float
+    compression_ratio: float
+    no_speech_prob: float
+
+
+class OpenAIVerboseTranscriptionResponseBody(OpenAIEndpointResponseBody):
+    # TODO: check output object with different
+    # timestamp_granularities in request body
+    task: str = Field("transcribe", description="The task performed")
+    language: str = Field(
+        description="The detected or specified language of the input audio"
+    )
+    duration: float = Field(
+        description="The duration of the input audio in seconds"
+    )
+    text: str = Field(description="The transcribed text")
+    words: list[Word] | None = Field(None, description="Word-level timestamps")
+    segments: list[Segment] | None = Field(description="Segment-level details")
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "task": "transcribe",
+                "language": "english",
+                "duration": 8.470000267028809,
+                "text": (
+                    "The beach was a popular spot on a hot "
+                    "summer day. People were swimming in the ocean,"
+                    " building sandcastles, and playing beach volleyball."
+                ),
+                "segments": [
+                    {
+                        "id": 0,
+                        "seek": 0,
+                        "start": 0.0,
+                        "end": 3.319999933242798,
+                        "text": (
+                            " The beach was a popular "
+                            "spot on a hot summer day."
+                        ),
+                        "tokens": [
+                            50364,
+                            440,
+                            7534,
+                            390,
+                            257,
+                            3743,
+                            4008,
+                            322,
+                            257,
+                            2368,
+                            4266,
+                            786,
+                            13,
+                            50530,
+                        ],
+                        "temperature": 0.0,
+                        "avg_logprob": -0.2860786020755768,
+                        "compression_ratio": 1.2363636493682861,
+                        "no_speech_prob": 0.00985979475080967,
+                    }
+                ],
+            }
+        }
+    )

lionagi/integrations/openai_/api_endpoints/audio/translation_models.py

@@ -0,0 +1,41 @@
+from typing import IO, Optional
+
+from pydantic import ConfigDict, Field, field_validator
+
+from ..data_models import OpenAIEndpointRequestBody, OpenAIEndpointResponseBody
+from .types import TranscriptionResponseFormat, WhisperModel
+
+
+class OpenAITranslationRequestBody(OpenAIEndpointRequestBody):
+    file: str | IO = Field(description="The audio file to translate")
+    model: WhisperModel = Field(description="The model to use for translation")
+    prompt: str | None = Field(
+        None,
+        description="An optional text to guide the model's style "
+        "or continue a previous audio segment",
+    )
+    response_format: TranscriptionResponseFormat = Field(
+        default="json",
+        description="The format of the transcript output",
+    )
+    temperature: float = Field(
+        default=0, ge=0, le=1, description="The sampling temperature"
+    )
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @field_validator("file")
+    @classmethod
+    def get_file_object(cls, value):
+        if isinstance(value, str):
+            value = open(value, "rb")
+        return value
+
+    def __del__(self):
+        # Ensure the file is closed when the object is destroyed
+        file_obj = self.__dict__.get("file")
+        if file_obj and not file_obj.closed:
+            file_obj.close()
+
+
+class OpenAITranslationResponseBody(OpenAIEndpointResponseBody):
+    text: str = Field(description="The translated text")

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

@@ -0,0 +1,41 @@
+from enum import Enum
+
+
+class TTSModel(str, Enum):
+    TTS_1 = "tts-1"
+    TTS_1_HD = "tts-1-hd"
+
+
+class Voice(str, Enum):
+    ALLOY = "alloy"
+    ECHO = "echo"
+    FABLE = "fable"
+    ONYX = "onyx"
+    NOVA = "nova"
+    SHIMMER = "shimmer"
+
+
+class AudioFormat(str, Enum):
+    MP3 = "mp3"
+    OPUS = "opus"
+    AAC = "aac"
+    FLAC = "flac"
+    WAV = "wav"
+    PCM = "pcm"
+
+
+class WhisperModel(str, Enum):
+    WHISPER_1 = "whisper-1"
+
+
+class TranscriptionResponseFormat(str, Enum):
+    JSON = "json"
+    TEXT = "text"
+    SRT = "srt"
+    VERBOSE_JSON = "verbose_json"
+    VTT = "vtt"
+
+
+class TimestampGranularity(str, Enum):
+    WORD = "word"
+    SEGMENT = "segment"

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

@@ -0,0 +1,17 @@
+from .cancel_batch import OpenAICancelBatchPathParam
+from .create_batch import OpenAIBatchRequestBody
+from .list_batch import OpenAIListBatchQueryParam
+from .request_object_models import (
+    OpenAIBatchRequestInputObject,
+    OpenAIBatchRequestOutputObject,
+)
+from .retrieve_batch import OpenAIRetrieveBatchPathParam
+
+__all__ = [
+    "OpenAIBatchRequestBody",
+    "OpenAIRetrieveBatchPathParam",
+    "OpenAICancelBatchPathParam",
+    "OpenAIListBatchQueryParam",
+    "OpenAIBatchRequestInputObject",
+    "OpenAIBatchRequestOutputObject",
+]

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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,7 @@
+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

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

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

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

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

@@ -0,0 +1,39 @@
+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",
+]