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

lionagi/integrations/openai_/OpenAIService.py

@@ -1,426 +0,0 @@
-import inspect
-
-from dotenv import load_dotenv
-
-from lionagi.service import Service, register_service
-
-from .api_endpoints.api_request import OpenAIRequest
-from .api_endpoints.match_data_model import match_data_model
-from .OpenAIModel import OpenAIModel
-
-load_dotenv()
-
-
-@register_service
-class OpenAIService(Service):
-    def __init__(
-        self,
-        api_key: str,
-        openai_organization: str = None,
-        openai_project: str = None,
-        name: str = None,
-    ):
-        super().__setattr__("_initialized", False)
-        self.api_key = api_key
-        self.openai_organization = openai_organization
-        self.openai_project = openai_project
-        self.name = name
-        self.rate_limiters = {}  # model: RateLimiter
-        super().__setattr__("_initialized", True)
-
-    def __setattr__(self, key, value):
-        if getattr(self, "_initialized", False) and key in [
-            "api_key",
-            "openai_organization",
-            "openai_project",
-        ]:
-            raise AttributeError(
-                f"Cannot modify '{key}' after initialization. "
-                f"Please set a new service object for new keys."
-            )
-        super().__setattr__(key, value)
-
-    def check_rate_limiter(
-        self,
-        openai_model: OpenAIModel,
-        limit_requests: int = None,
-        limit_tokens: int = None,
-    ):
-        shared_models = {
-            "gpt-4-turbo-2024-04-09": "gpt-4-turbo",
-            "gpt-4-turbo-preview": "gpt-4-turbo",
-            "gpt-4-0125-preview": "gpt-4-turbo",
-            "gpt-4-1106-preview": "gpt-4-turbo",
-            "gpt-4o-2024-05-13": "gpt-4o",
-            "gpt-4o-2024-08-06": "gpt-4o",
-            "gpt-4o-mini-2024-07-18": "gpt-4o-mini",
-        }
-
-        if openai_model.model in shared_models:
-            model = shared_models[openai_model.model]
-        else:
-            model = openai_model.model
-
-        if model not in self.rate_limiters:
-            self.rate_limiters[model] = openai_model.rate_limiter
-        else:
-            openai_model.rate_limiter = self.rate_limiters[model]
-            if limit_requests:
-                openai_model.rate_limiter.limit_requests = limit_requests
-            if limit_tokens:
-                openai_model.rate_limiter.limit_tokens = limit_tokens
-
-        return openai_model
-
-    @staticmethod
-    def match_data_model(task_name):
-        return match_data_model(task_name)
-
-    @classmethod
-    def list_tasks(cls):
-        methods = []
-        for name, member in inspect.getmembers(
-            cls, predicate=inspect.isfunction
-        ):
-            if name not in [
-                "__init__",
-                "__setattr__",
-                "check_rate_limiter",
-                "match_data_model",
-            ]:
-                methods.append(name)
-        return methods
-
-    # Audio
-    def create_speech(self, model: str, limit_requests: int = None):
-        model_obj = OpenAIModel(
-            model=model,
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="audio/speech",
-            method="POST",
-            content_type="application/json",
-            limit_requests=limit_requests,
-        )
-
-        return self.check_rate_limiter(
-            model_obj, limit_requests=limit_requests
-        )
-
-    def create_transcription(self, model: str, limit_requests: int = None):
-        model_obj = OpenAIModel(
-            model=model,
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="audio/transcriptions",
-            method="POST",
-            limit_requests=limit_requests,
-        )
-
-        return self.check_rate_limiter(
-            model_obj, limit_requests=limit_requests
-        )
-
-    def create_translation(self, model: str, limit_requests: int = None):
-        model_obj = OpenAIModel(
-            model=model,
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="audio/translations",
-            method="POST",
-            limit_requests=limit_requests,
-        )
-
-        return self.check_rate_limiter(
-            model_obj, limit_requests=limit_requests
-        )
-
-    # Chat
-    def create_chat_completion(
-        self, model: str, limit_tokens: int = None, limit_requests: int = None
-    ):
-        model_obj = OpenAIModel(
-            model=model,
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="chat/completions",
-            method="POST",
-            content_type="application/json",
-            limit_tokens=limit_tokens,
-            limit_requests=limit_requests,
-        )
-
-        return self.check_rate_limiter(
-            model_obj, limit_requests=limit_requests, limit_tokens=limit_tokens
-        )
-
-    # Embeddings
-    def create_embeddings(
-        self, model: str, limit_tokens: int = None, limit_requests: int = None
-    ):
-        model_obj = OpenAIModel(
-            model=model,
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="embeddings",
-            method="POST",
-            content_type="application/json",
-            limit_tokens=limit_tokens,
-            limit_requests=limit_requests,
-        )
-        return self.check_rate_limiter(
-            model_obj, limit_requests=limit_requests, limit_tokens=limit_tokens
-        )
-
-    # Fine_tuning
-    def create_fine_tuning_job(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="fine_tuning/jobs",
-            method="POST",
-            content_type="application/json",
-        )
-
-    def list_fine_tuning_jobs(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="fine_tuning/jobs",
-            method="GET",
-        )
-
-    def list_fine_tuning_events(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="fine_tuning/jobs/{fine_tuning_job_id}/events",
-            method="GET",
-        )
-
-    def list_fine_tuning_checkpoints(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="fine_tuning/jobs/{fine_tuning_job_id}/checkpoints",
-            method="GET",
-        )
-
-    def retrieve_fine_tuning_job(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="fine_tuning/jobs/{fine_tuning_job_id}",
-            method="GET",
-        )
-
-    def cancel_fine_tuning(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="fine_tuning/jobs/{fine_tuning_job_id}/cancel",
-            method="POST",
-        )
-
-    # Batch
-    def create_batch(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="batches",
-            method="POST",
-            content_type="application/json",
-        )
-
-    def retrieve_batch(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="batches/{batch_id}",
-            method="GET",
-            content_type="application/json",
-        )
-
-    def cancel_batch(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="batches/{batch_id}/cancel",
-            method="POST",
-            content_type="application/json",
-        )
-
-    def list_batch(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="batches",
-            method="GET",
-            content_type="application/json",
-        )
-
-    # Files
-    def upload_file(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="files",
-            method="POST",
-        )
-
-    def list_files(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="files",
-            method="GET",
-        )
-
-    def retrieve_file(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="files/{file_id}",
-            method="GET",
-        )
-
-    def delete_file(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="files/{file_id}",
-            method="DELETE",
-        )
-
-    def retrieve_file_content(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="files/{file_id}/content",
-            method="GET",
-        )
-
-    # Uploads
-    def create_upload(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="uploads",
-            method="POST",
-        )
-
-    def add_upload_part(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="uploads/{upload_id}/parts",
-            method="POST",
-        )
-
-    def complete_upload(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="uploads/{upload_id}/complete",
-            method="POST",
-        )
-
-    def cancel_upload(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="uploads/{upload_id}/cancel",
-            method="POST",
-        )
-
-    # Images
-    def create_image(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="images/generations",
-            method="POST",
-            content_type="application/json",
-        )
-
-    def create_image_edit(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="images/edits",
-            method="POST",
-        )
-
-    def create_image_variation(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="images/variations",
-            method="POST",
-        )
-
-    # Models
-    def list_models(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="models",
-            method="GET",
-        )
-
-    def retrieve_model(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="models/{model}",
-            method="GET",
-        )
-
-    def delete_fine_tuned_model(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="models/{model}",
-            method="DELETE",
-        )
-
-    # Moderations
-    def create_moderation(self):
-        return OpenAIRequest(
-            api_key=self.api_key,
-            openai_organization=self.openai_organization,
-            openai_project=self.openai_project,
-            endpoint="moderations",
-            method="POST",
-            content_type="application/json",
-        )

lionagi/integrations/openai_/api_endpoints/__init__.py

@@ -1,3 +0,0 @@
-from .api_request import OpenAIRequest
-
-__all__ = ["OpenAIRequest"]

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})"
-        )