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

lionagi/integrations/openai_/api_endpoints/fine_tuning/create_jobs.py

@@ -0,0 +1,133 @@
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ..data_models import OpenAIEndpointRequestBody
+
+
+class Wandb(BaseModel):
+    project: str = Field(
+        description="The name of the project for the new run."
+    )
+
+    name: str | None = Field(None, description="A display name for the run.")
+
+    entity: str | None = Field(
+        None, description="The entity (team or username) for the WandB run."
+    )
+
+    tags: list[str] | None = Field(
+        None,
+        description="A list of tags to be attached to the newly created run.",
+    )
+
+
+class Integration(BaseModel):
+    type: Literal["wandb"] = Field(
+        description="The type of integration to enable."
+        " Only 'wandb' is supported."
+    )
+
+    wandb: Wandb = Field(
+        description="Settings for Weights and Biases integration."
+    )
+
+
+class Hyperparameters(BaseModel):
+    batch_size: str | int | None = Field(
+        "auto",
+        description=(
+            "Number of examples in each batch. A larger"
+            " batch size means that "
+            "model parameters are updated less frequently, but with lower variance."
+        ),
+    )
+    learning_rate_multiplier: str | float | None = Field(
+        "auto",
+        description=(
+            "Scaling factor for the learning rate. A smaller learning rate "
+            "may be useful to avoid overfitting."
+        ),
+    )
+    n_epochs: str | int | None = Field(
+        "auto",
+        description=(
+            "The number of epochs to train the model for. An epoch refers "
+            "to one full cycle through the training dataset."
+        ),
+    )
+
+    # TODO: check hyperparameters
+    model_config = ConfigDict(extra="allow")
+
+
+class OpenAICreateFineTuningJobRequestBody(OpenAIEndpointRequestBody):
+    model: str = Field(description="The name of the model to fine-tune.")
+
+    training_file: str = Field(
+        description=(
+            "The ID of an uploaded file that contains training data. "
+            "Must be a JSONL file with 'purpose' set to 'fine-tune'."
+        ),
+    )
+
+    hyperparameters: Hyperparameters | None = Field(
+        None, description="The hyperparameters used for the fine-tuning job."
+    )
+
+    suffix: str | None = Field(
+        None,
+        max_length=64,
+        description=(
+            "A string of up to 64 characters that will be added to your "
+            "fine-tuned model name."
+        ),
+    )
+
+    validation_file: str | None = Field(
+        None,
+        description=(
+            "The ID of an uploaded file that contains validation data. "
+            "Must be a JSONL file with 'purpose' set to 'fine-tune'."
+        ),
+    )
+    integrations: list[Integration] | None = Field(
+        None,
+        description="A list of integrations to enable for your fine-tuning job.",
+    )
+
+    seed: int | None = Field(
+        None,
+        description=(
+            "The seed controls the reproducibility of the job. Passing in the "
+            "same seed and job parameters should produce the same results."
+        ),
+    )
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "training_file": "file-BK7bzQj3FfZFXr7DbL6xJwfo",
+                "model": "gpt-4o-mini",
+                "hyperparameters": {
+                    "batch_size": "auto",
+                    "learning_rate_multiplier": "auto",
+                    "n_epochs": "auto",
+                },
+                "suffix": "custom-model-name",
+                "validation_file": None,
+                "integrations": [
+                    {
+                        "type": "wandb",
+                        "wandb": {
+                            "project": "my-project",
+                            "name": "my-run",
+                            "entity": "my-team",
+                            "tags": ["tag1", "tag2"],
+                        },
+                    }
+                ],
+                "seed": 42,
+            }
+        }
+    )

lionagi/integrations/openai_/api_endpoints/fine_tuning/fine_tuning_job_checkpoint_models.py

@@ -0,0 +1,58 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ..data_models import OpenAIEndpointResponseBody
+
+
+class Metrics(BaseModel):
+    step: int = Field(
+        description="The step number associated with these metrics."
+    )
+
+    train_loss: float = Field(description="The training loss at this step.")
+
+    train_mean_token_accuracy: float = Field(
+        description="The mean token accuracy during training at this step."
+    )
+    valid_loss: float = Field(description="The validation loss at this step.")
+
+    valid_mean_token_accuracy: float = Field(
+        description="The mean token accuracy during validation at this step."
+    )
+
+    full_valid_loss: float = Field(
+        description="The full validation loss at this step."
+    )
+
+    full_valid_mean_token_accuracy: float = Field(
+        description="The full mean token accuracy during validation at this step."
+    )
+
+
+class OpenAIFineTuningJobCheckpointResponseBody(OpenAIEndpointResponseBody):
+    id: str = Field(description="The ID of the checkpoint.")
+
+    created_at: int = Field(
+        description="The Unix timestamp (in seconds) of when the checkpoint was created.",
+    )
+
+    fine_tuned_model_checkpoint: str = Field(
+        description="The name of the fine-tuned model checkpoint."
+    )
+
+    step_number: int = Field(
+        description="The step number of this checkpoint in the fine-tuning process.",
+    )
+
+    metrics: Metrics = Field(
+        description="Metrics associated with the checkpoint."
+    )
+
+    fine_tuning_job_id: str = Field(
+        description="The ID of the fine-tuning job this checkpoint belongs to."
+    )
+
+    object: Literal["fine_tuning.job.checkpoint"] = Field(
+        description="The object type, always 'fine_tuning.job.checkpoint'.",
+    )

lionagi/integrations/openai_/api_endpoints/fine_tuning/fine_tuning_job_event_models.py

@@ -0,0 +1,31 @@
+from typing import Literal, Optional
+
+from pydantic import Field
+
+from ..data_models import OpenAIEndpointResponseBody
+
+
+class OpenAIFineTuningJobEventResponseBody(OpenAIEndpointResponseBody):
+    id: str = Field(description="The ID of the fine-tuning event.")
+
+    created_at: int = Field(
+        description="The Unix timestamp (in seconds) of when the event was created.",
+    )
+
+    level: str = Field(description="The level of the event (e.g., 'info').")
+
+    object: Literal["fine_tuning.job.event"] = Field(
+        "fine_tuning.job.event",
+        description="The object type, always 'fine_tuning.job.event'.",
+    )
+
+    message: str = Field(
+        ..., description="The message associated with the event."
+    )
+
+    # TODO: check Job Event Response
+    data: dict | None = Field(
+        None, description="Additional data associated with the event, if any."
+    )
+
+    type: str = Field(description="The type of the event (e.g., 'message').")

lionagi/integrations/openai_/api_endpoints/fine_tuning/fine_tuning_job_models.py

@@ -0,0 +1,140 @@
+from enum import Enum
+from typing import List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ..data_models import OpenAIEndpointResponseBody
+
+
+class Status(str, Enum):
+    VALIDATING_FILES = "validating_files"
+    QUEUED = "queued"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class Error(BaseModel):
+    code: str | None = Field(
+        None, description="A machine-readable error code."
+    )
+
+    message: str | None = Field(
+        None, description="A human-readable error message."
+    )
+
+    param: str | None = Field(
+        None, description="The parameter that was invalid, if applicable."
+    )
+
+
+class Hyperparameters(BaseModel):
+    n_epochs: Literal["auto"] | int = Field(
+        description="The number of epochs to train the model for. 'auto' or 1-50.",
+    )
+
+    # TODO: check hyperparameters
+    batch_size: Literal["auto"] | int = Field(
+        None, description="The batch size."
+    )
+
+    learning_rate_multiplier: Literal["auto"] | int = Field(
+        None, description="The learning rate multiplier."
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+
+class Wandb(BaseModel):
+    project: str = Field(
+        ..., description="The name of the project for the new run."
+    )
+
+    name: str | None = Field(None, description="A display name for the run.")
+
+    entity: str | None = Field(
+        None, description="The entity to use for the run."
+    )
+
+    tags: list[str] | None = Field(description="A list of tags for the run.")
+
+
+class Integration(BaseModel):
+    type: str = Field(
+        ..., description="The type of the integration being enabled."
+    )
+
+    wandb: Wandb | None = Field(
+        None, description="Settings for Weights and Biases integration."
+    )
+
+
+class OpenAIFineTuningJobResponseBody(OpenAIEndpointResponseBody):
+    id: str = Field(
+        description="The object identifier, referenceable in API endpoints."
+    )
+
+    created_at: int = Field(
+        ..., description="The Unix timestamp (in seconds) of job creation."
+    )
+
+    error: Error | None = Field(
+        None, description="Error information for failed jobs."
+    )
+
+    fine_tuned_model: str | None = Field(
+        None, description="The name of the fine-tuned model being created."
+    )
+
+    finished_at: int | None = Field(
+        None, description="The Unix timestamp (in seconds) of job completion."
+    )
+
+    hyperparameters: Hyperparameters = Field(
+        description="The hyperparameters used for the fine-tuning job."
+    )
+
+    model: str = Field(description="The base model being fine-tuned.")
+
+    object: Literal["fine_tuning.job"] = Field(
+        description="The object type, always 'fine_tuning.job'."
+    )
+
+    organization_id: str = Field(
+        ..., description="The organization that owns the fine-tuning job."
+    )
+
+    result_files: list[str] = Field(
+        ..., description="The compiled results file ID(s) for the job."
+    )
+
+    status: Status = Field(
+        description=(
+            "The current status of the fine-tuning job: validating_files, "
+            "queued, running, succeeded, failed, or cancelled."
+        ),
+    )
+
+    trained_tokens: int | None = Field(
+        None, description="The total number of billable tokens processed."
+    )
+
+    training_file: str = Field(description="The file ID used for training.")
+
+    validation_file: str | None = Field(
+        None, description="The file ID used for validation."
+    )
+
+    integrations: list[Integration] | None = Field(
+        None, description="A list of integrations enabled for this job."
+    )
+
+    seed: int = Field(
+        None, description="The seed used for the fine-tuning job."
+    )
+
+    estimated_finish: int | None = Field(
+        None,
+        description="The Unix timestamp (in seconds) for estimated job completion.",
+    )

lionagi/integrations/openai_/api_endpoints/fine_tuning/list_fine_tuning_checkpoints.py

@@ -0,0 +1,51 @@
+from typing import List, Literal, Optional
+
+from pydantic import Field
+
+from ..data_models import (
+    OpenAIEndpointPathParam,
+    OpenAIEndpointQueryParam,
+    OpenAIEndpointResponseBody,
+)
+from .fine_tuning_job_checkpoint_models import (
+    OpenAIFineTuningJobCheckpointResponseBody,
+)
+
+
+class OpenAIListFineTuningCheckpointsPathParam(OpenAIEndpointPathParam):
+    fine_tuning_job_id: str = Field(
+        description="The ID of the fine-tuning job to get checkpoints for."
+    )
+
+
+class OpenAIListFineTuningCheckpointsQueryParam(OpenAIEndpointQueryParam):
+    after: str | None = Field(
+        None,
+        description="Identifier for the last checkpoint ID from the previous pagination request.",
+    )
+
+    limit: int | None = Field(
+        10, description="Number of checkpoints to retrieve.", ge=1
+    )
+
+
+class OpenAIListFineTuningCheckpointsResponseBody(OpenAIEndpointResponseBody):
+    object: Literal["list"] = Field(
+        description="The object type, always 'list' for a list of fine-tuning checkpoints.",
+    )
+
+    data: list[OpenAIFineTuningJobCheckpointResponseBody] = Field(
+        description="A list of fine-tuning checkpoints."
+    )
+
+    first_id: str | None = Field(
+        None, description="The ID of the first checkpoint in the list."
+    )
+
+    last_id: str | None = Field(
+        None, description="The ID of the last checkpoint in the list."
+    )
+
+    has_more: bool = Field(
+        description="Whether there are more results available after this batch."
+    )

lionagi/integrations/openai_/api_endpoints/fine_tuning/list_fine_tuning_events.py

@@ -0,0 +1,42 @@
+from typing import List, Literal, Optional
+
+from pydantic import Field
+
+from ..data_models import (
+    OpenAIEndpointPathParam,
+    OpenAIEndpointQueryParam,
+    OpenAIEndpointResponseBody,
+)
+from .fine_tuning_job_event_models import OpenAIFineTuningJobEventResponseBody
+
+
+# Request model
+class OpenAIListFineTuningEventsPathParam(OpenAIEndpointPathParam):
+    fine_tuning_job_id: str = Field(
+        description="The ID of the fine-tuning job to get events for."
+    )
+
+
+class OpenAIListFineTuningEventsQueryParam(OpenAIEndpointQueryParam):
+    after: str | None = Field(
+        None,
+        description="Identifier for the last event from the previous pagination request.",
+    )
+
+    limit: int | None = Field(
+        20, description="Number of events to retrieve.", ge=1
+    )
+
+
+class OpenAIListFineTuningEventsResponseBody(OpenAIEndpointResponseBody):
+    object: Literal["list"] = Field(
+        description="The object type, always 'list' for a list of fine-tuning events.",
+    )
+
+    data: list[OpenAIFineTuningJobEventResponseBody] = Field(
+        description="A list of fine-tuning events."
+    )
+
+    has_more: bool = Field(
+        description="Whether there are more results available after this batch."
+    )

lionagi/integrations/openai_/api_endpoints/fine_tuning/list_fine_tuning_jobs.py

@@ -0,0 +1,31 @@
+from typing import List, Literal, Optional
+
+from pydantic import Field
+
+from ..data_models import OpenAIEndpointQueryParam, OpenAIEndpointResponseBody
+from .fine_tuning_job_models import OpenAIFineTuningJobResponseBody
+
+
+class OpenAIListFineTuningJobsQueryParam(OpenAIEndpointQueryParam):
+    after: str | None = Field(
+        None,
+        description="Identifier for the last job from the previous pagination request.",
+    )
+
+    limit: int | None = Field(
+        20, description="Number of fine-tuning jobs to retrieve.", ge=1
+    )
+
+
+class OpenAIListFineTuningJobsResponseBody(OpenAIEndpointResponseBody):
+    object: Literal["list"] = Field(
+        description="The object type, always 'list' for a list of fine-tuning jobs.",
+    )
+
+    data: list[OpenAIFineTuningJobResponseBody] = Field(
+        description="A list of fine-tuning job events."
+    )
+
+    has_more: bool = Field(
+        description="Whether there are more results available after this batch."
+    )

lionagi/integrations/openai_/api_endpoints/fine_tuning/retrieve_jobs.py

@@ -0,0 +1,9 @@
+from pydantic import Field
+
+from ..data_models import OpenAIEndpointPathParam
+
+
+class OpenAIRetrieveFineTuningJobPathParam(OpenAIEndpointPathParam):
+    fine_tuning_job_id: str = Field(
+        description="The ID of the fine-tuning job to get events for."
+    )

lionagi/integrations/openai_/api_endpoints/fine_tuning/training_format.py

@@ -0,0 +1,30 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field, SerializeAsAny
+
+from ..chat_completions.request.request_body import Message, Tool
+
+
+class OpenAIChatModelTrainingFormat(BaseModel):
+    messages: SerializeAsAny[list[Message]] = Field(
+        description="A list of messages comprising the conversation so far."
+    )
+
+    tools: list[Tool] | None = Field(
+        None, description="A list of tools may generate JSON inputs for."
+    )
+
+    parallel_tool_calls: bool | None = Field(
+        True,
+        decription="Whether to enable parallel function calling during tool use.",
+    )
+
+
+class OpenAICompletionsModelTrainingFormat(BaseModel):
+    prompt: str = Field(
+        description="The input prompt for this training example."
+    )
+
+    completion: str = Field(
+        description="The desired completion for this training example."
+    )

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

@@ -0,0 +1,9 @@
+from .image_edit_models import OpenAIImageEditRequestBody
+from .image_models import OpenAIImageRequestBody
+from .image_variation_models import OpenAIImageVariationRequestBody
+
+__all__ = [
+    "OpenAIImageRequestBody",
+    "OpenAIImageEditRequestBody",
+    "OpenAIImageVariationRequestBody",
+]

lionagi/integrations/openai_/api_endpoints/images/image_edit_models.py

@@ -0,0 +1,69 @@
+from enum import Enum
+from typing import IO, Literal, Optional
+
+from pydantic import ConfigDict, Field, field_validator
+
+from ..data_models import OpenAIEndpointRequestBody
+
+
+class Size(str, Enum):
+    S256 = "256x256"
+    S512 = "512x512"
+    S1024 = "1024x1024"
+
+
+class OpenAIImageEditRequestBody(OpenAIEndpointRequestBody):
+    image: str | IO = Field(
+        description="The image to edit. Must be a valid PNG file, less than 4MB, and square.",
+    )
+
+    prompt: str = Field(
+        description="A text description of the desired image(s).",
+        max_length=1000,
+    )
+
+    mask: str | IO | None = Field(
+        None,
+        description="An additional image whose fully transparent areas indicate where image should be edited.",
+    )
+
+    model: Literal["dall-e-2"] | None = Field(
+        "dall-e-2", description="The model to use for image generation."
+    )
+
+    n: int | None = Field(
+        1, description="The number of images to generate.", ge=1, le=10
+    )
+
+    size: Size | None = Field(
+        "1024x1024", description="The size of the generated images."
+    )
+
+    response_format: Literal["url", "b64_json"] | None = Field(
+        "url",
+        description="The format in which the generated images are returned.",
+    )
+
+    user: str | None = Field(
+        None,
+        description="A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.",
+    )
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @field_validator("image", "mask")
+    @classmethod
+    def get_file_object(cls, value):
+        if isinstance(value, str):
+            value = open(value, "rb")
+        return value
+
+    def __del__(self):
+        # Ensure files are closed when the object is destroyed
+        image_obj = self.__dict__.get("image")
+        if image_obj and not image_obj.closed:
+            image_obj.close()
+
+        mask_obj = self.__dict__.get("mask")
+        if mask_obj and not mask_obj.closed:
+            mask_obj.close()

lionagi/integrations/openai_/api_endpoints/images/image_models.py

@@ -0,0 +1,56 @@
+from enum import Enum
+from typing import Literal, Optional
+
+from pydantic import Field
+
+from ..data_models import OpenAIEndpointRequestBody
+
+
+class Size(str, Enum):
+    S256 = "256x256"
+    S512 = "512x512"
+    S1024 = "1024x1024"
+    S1792_1024 = "1792x1024"
+    S1024_1792 = "1024x1792"
+
+
+class Style(str, Enum):
+    VIVID = "vivid"
+    NATURAL = "natural"
+
+
+class OpenAIImageRequestBody(OpenAIEndpointRequestBody):
+    prompt: str = Field(
+        description="A text description of the desired image(s)."
+    )
+
+    model: str = Field(
+        "dall-e-2", description="The model to use for image generation."
+    )
+
+    n: int | None = Field(
+        1, description="The number of images to generate.", ge=1, le=10
+    )
+
+    quality: Literal["standard", "hd"] | None = Field(
+        "standard",
+        description="The quality of the image that will be generated.",
+    )
+
+    response_format: Literal["url", "b64_json"] | None = Field(
+        "url",
+        description="The format in which the generated images are returned.",
+    )
+
+    size: Size | None = Field(
+        "1024x1024", description="The size of the generated images."
+    )
+
+    style: Style | None = Field(
+        "vivid", description="The style of the generated images."
+    )
+
+    user: str | None = Field(
+        None,
+        description="A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.",
+    )