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

lionagi/integrations/openai_/api_endpoints/api_request.py

@@ -1,277 +0,0 @@
-import json
-from io import IOBase
-from os import getenv
-
-import aiohttp
-from pydantic import BaseModel, Field, field_validator
-
-from .data_models import (
-    OpenAIEndpointPathParam,
-    OpenAIEndpointQueryParam,
-    OpenAIEndpointRequestBody,
-)
-from .match_response import match_response
-
-
-class OpenAIRequest(BaseModel):
-
-    api_key: str = Field(
-        description="API key for authentication", exclude=True
-    )
-
-    openai_organization: str | None = Field(
-        default=None, description="Organization id", exclude=True
-    )
-
-    openai_project: str | None = Field(
-        default=None, description="Project id", 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"
-    )
-
-    @field_validator("api_key", "openai_organization", "openai_project")
-    @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: OpenAIEndpointPathParam = 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.openai.com/v1/"
-
-    async def invoke(
-        self,
-        json_data: OpenAIEndpointRequestBody = None,
-        params: OpenAIEndpointQueryParam = None,
-        form_data: OpenAIEndpointRequestBody = None,
-        path_param: OpenAIEndpointPathParam = None,
-        output_file: str = None,
-        with_response_header: bool = False,
-        parse_response: bool = True,
-    ):
-        def get_headers():
-            header = {"Authorization": f"Bearer {self.api_key}"}
-            if self.content_type:
-                header["Content-Type"] = self.content_type
-            if self.openai_organization:
-                header["OpenAI-Organization"] = self.openai_organization
-            if self.openai_project:
-                header["OpenAI-Project"] = self.openai_project
-            return header
-
-        def parse_form_data(data: OpenAIEndpointRequestBody):
-            form_data = aiohttp.FormData()
-            # for field in data.model_fields:
-            for field in data.model_dump(exclude_unset=True):
-                if value := getattr(data, field):
-                    if isinstance(value, IOBase):
-                        form_data.add_field(field, getattr(data, field))
-                    else:
-                        form_data.add_field(field, str(getattr(data, field)))
-            return form_data
-
-        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
-        form_data = parse_form_data(form_data) if form_data else None
-
-        async with aiohttp.ClientSession() as client:
-            async with client.request(
-                method=self.method,
-                url=url,
-                headers=headers,
-                json=json_data,
-                params=params,
-                data=form_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,
-                    )
-
-                # handle stream in chat completions
-                if json_data:
-                    if 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")
-                                chunk_list = chunk_str.split("data:")
-                                for c in chunk_list:
-                                    c = c.strip()
-                                    if c and "DONE" not in c:
-                                        if file_handle:
-                                            file_handle.write(c + "\n")
-                                        response_body.append(json.loads(c))
-
-                        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}"
-                        )
-                if self.endpoint != "audio/speech":
-                    if (
-                        response.headers.get("Content-Type")
-                        == "application/json"
-                    ):
-                        response_body = await response.json()
-                    else:
-                        response_body = await response.text()
-
-                    if parse_response:
-                        response_body = match_response(self, response_body)
-                    if with_response_header:
-                        return response_body, response.headers
-                    else:
-                        return response_body
-
-                else:
-                    if with_response_header:
-                        return (
-                            None,
-                            response.headers,
-                        )  # audio/speech has no response object
-                    else:
-                        return None
-
-    async def stream(
-        self,
-        json_data: OpenAIEndpointRequestBody,
-        verbose: bool = True,
-        output_file: str = None,
-        with_response_header: bool = False,
-    ):
-        # for Chat Completions API only
-        if not getattr(json_data, "stream"):
-            raise ValueError(
-                "Request does not support stream. "
-                "Only chat completions requests with stream=True are supported"
-            )
-
-        def get_headers():
-            header = {"Authorization": f"Bearer {self.api_key}"}
-            if self.content_type:
-                header["Content-Type"] = self.content_type
-            if self.openai_organization:
-                header["OpenAI-Organization"] = self.openai_organization
-            if self.openai_project:
-                header["OpenAI-Project"] = self.openai_project
-            return header
-
-        url = self.base_url + self.get_endpoint()
-        headers = get_headers()
-        json_data = (
-            json_data.model_dump(exclude_unset=True) if json_data else None
-        )
-
-        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")
-                        chunk_list = chunk_str.split("data:")
-                        for c in chunk_list:
-                            c = c.strip()
-                            if c and "DONE" not in c:
-                                if file_handle:
-                                    file_handle.write(c + "\n")
-                                c_dict = json.loads(c)
-                                if verbose:
-                                    if c_dict.get("choices"):
-                                        if content := c_dict["choices"][0][
-                                            "delta"
-                                        ].get("content"):
-                                            print(content, end="", flush=True)
-                                yield c_dict
-
-                    if with_response_header:
-                        yield response.headers
-
-                finally:
-                    if file_handle:
-                        file_handle.close()
-
-    def __repr__(self):
-        return (
-            f"OpenAIRequest(endpoint={self.endpoint}, method={self.method}, "
-            f"content_type={self.content_type})"
-        )

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

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

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

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

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

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

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