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

lionagi/integrations/openai_/OpenAIService.py

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

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

lionagi/integrations/openai_/api_endpoints/api_request.py

@@ -0,0 +1,277 @@
+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})"
+        )