openapiopenai 1.0.0__py3-none-any.whl

openapiopenai/models/__init__.py

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+    OpenAI API
+
+    APIs for sampling from and fine-tuning language models
+
+    The version of the OpenAPI document: 2.0.0
+    Contact: blah+oapicf@cliffano.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+# import models into model package
+from openapiopenai.models.chat_completion_functions import ChatCompletionFunctions
+from openapiopenai.models.chat_completion_request_message import ChatCompletionRequestMessage
+from openapiopenai.models.chat_completion_request_message_function_call import ChatCompletionRequestMessageFunctionCall
+from openapiopenai.models.chat_completion_response_message import ChatCompletionResponseMessage
+from openapiopenai.models.chat_completion_stream_response_delta import ChatCompletionStreamResponseDelta
+from openapiopenai.models.create_chat_completion_request import CreateChatCompletionRequest
+from openapiopenai.models.create_chat_completion_request_function_call import CreateChatCompletionRequestFunctionCall
+from openapiopenai.models.create_chat_completion_request_function_call_one_of import CreateChatCompletionRequestFunctionCallOneOf
+from openapiopenai.models.create_chat_completion_request_model import CreateChatCompletionRequestModel
+from openapiopenai.models.create_chat_completion_request_stop import CreateChatCompletionRequestStop
+from openapiopenai.models.create_chat_completion_response import CreateChatCompletionResponse
+from openapiopenai.models.create_chat_completion_response_choices_inner import CreateChatCompletionResponseChoicesInner
+from openapiopenai.models.create_chat_completion_stream_response import CreateChatCompletionStreamResponse
+from openapiopenai.models.create_chat_completion_stream_response_choices_inner import CreateChatCompletionStreamResponseChoicesInner
+from openapiopenai.models.create_completion_request import CreateCompletionRequest
+from openapiopenai.models.create_completion_request_model import CreateCompletionRequestModel
+from openapiopenai.models.create_completion_request_prompt import CreateCompletionRequestPrompt
+from openapiopenai.models.create_completion_request_stop import CreateCompletionRequestStop
+from openapiopenai.models.create_completion_response import CreateCompletionResponse
+from openapiopenai.models.create_completion_response_choices_inner import CreateCompletionResponseChoicesInner
+from openapiopenai.models.create_completion_response_choices_inner_logprobs import CreateCompletionResponseChoicesInnerLogprobs
+from openapiopenai.models.create_completion_response_usage import CreateCompletionResponseUsage
+from openapiopenai.models.create_edit_request import CreateEditRequest
+from openapiopenai.models.create_edit_request_model import CreateEditRequestModel
+from openapiopenai.models.create_edit_response import CreateEditResponse
+from openapiopenai.models.create_edit_response_choices_inner import CreateEditResponseChoicesInner
+from openapiopenai.models.create_embedding_request import CreateEmbeddingRequest
+from openapiopenai.models.create_embedding_request_input import CreateEmbeddingRequestInput
+from openapiopenai.models.create_embedding_request_model import CreateEmbeddingRequestModel
+from openapiopenai.models.create_embedding_response import CreateEmbeddingResponse
+from openapiopenai.models.create_embedding_response_data_inner import CreateEmbeddingResponseDataInner
+from openapiopenai.models.create_embedding_response_usage import CreateEmbeddingResponseUsage
+from openapiopenai.models.create_fine_tune_request import CreateFineTuneRequest
+from openapiopenai.models.create_fine_tune_request_model import CreateFineTuneRequestModel
+from openapiopenai.models.create_image_request import CreateImageRequest
+from openapiopenai.models.create_moderation_request import CreateModerationRequest
+from openapiopenai.models.create_moderation_request_input import CreateModerationRequestInput
+from openapiopenai.models.create_moderation_request_model import CreateModerationRequestModel
+from openapiopenai.models.create_moderation_response import CreateModerationResponse
+from openapiopenai.models.create_moderation_response_results_inner import CreateModerationResponseResultsInner
+from openapiopenai.models.create_moderation_response_results_inner_categories import CreateModerationResponseResultsInnerCategories
+from openapiopenai.models.create_moderation_response_results_inner_category_scores import CreateModerationResponseResultsInnerCategoryScores
+from openapiopenai.models.create_transcription_request_model import CreateTranscriptionRequestModel
+from openapiopenai.models.create_transcription_response import CreateTranscriptionResponse
+from openapiopenai.models.create_translation_response import CreateTranslationResponse
+from openapiopenai.models.delete_file_response import DeleteFileResponse
+from openapiopenai.models.delete_model_response import DeleteModelResponse
+from openapiopenai.models.error import Error
+from openapiopenai.models.error_response import ErrorResponse
+from openapiopenai.models.fine_tune import FineTune
+from openapiopenai.models.fine_tune_event import FineTuneEvent
+from openapiopenai.models.images_response import ImagesResponse
+from openapiopenai.models.images_response_data_inner import ImagesResponseDataInner
+from openapiopenai.models.list_files_response import ListFilesResponse
+from openapiopenai.models.list_fine_tune_events_response import ListFineTuneEventsResponse
+from openapiopenai.models.list_fine_tunes_response import ListFineTunesResponse
+from openapiopenai.models.list_models_response import ListModelsResponse
+from openapiopenai.models.model import Model
+from openapiopenai.models.open_ai_file import OpenAIFile

openapiopenai/models/chat_completion_functions.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    OpenAI API
+
+    APIs for sampling from and fine-tuning language models
+
+    The version of the OpenAPI document: 2.0.0
+    Contact: blah+oapicf@cliffano.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatCompletionFunctions(BaseModel):
+    """
+    ChatCompletionFunctions
+    """ # noqa: E501
+    name: StrictStr = Field(description="The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.")
+    description: Optional[StrictStr] = Field(default=None, description="The description of what the function does.")
+    parameters: Optional[Dict[str, Any]] = Field(default=None, description="The parameters the functions accepts, described as a JSON Schema object. See the [guide](/docs/guides/gpt/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.")
+    __properties: ClassVar[List[str]] = ["name", "description", "parameters"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ChatCompletionFunctions from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatCompletionFunctions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "parameters": obj.get("parameters")
+        })
+        return _obj
+
+

openapiopenai/models/chat_completion_request_message.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    OpenAI API
+
+    APIs for sampling from and fine-tuning language models
+
+    The version of the OpenAPI document: 2.0.0
+    Contact: blah+oapicf@cliffano.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from openapiopenai.models.chat_completion_request_message_function_call import ChatCompletionRequestMessageFunctionCall
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatCompletionRequestMessage(BaseModel):
+    """
+    ChatCompletionRequestMessage
+    """ # noqa: E501
+    role: StrictStr = Field(description="The role of the messages author. One of `system`, `user`, `assistant`, or `function`.")
+    content: Optional[StrictStr] = Field(default=None, description="The contents of the message. `content` is required for all messages except assistant messages with function calls.")
+    name: Optional[StrictStr] = Field(default=None, description="The name of the author of this message. `name` is required if role is `function`, and it should be the name of the function whose response is in the `content`. May contain a-z, A-Z, 0-9, and underscores, with a maximum length of 64 characters.")
+    function_call: Optional[ChatCompletionRequestMessageFunctionCall] = None
+    __properties: ClassVar[List[str]] = ["role", "content", "name", "function_call"]
+
+    @field_validator('role')
+    def role_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['system', 'user', 'assistant', 'function']):
+            raise ValueError("must be one of enum values ('system', 'user', 'assistant', 'function')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ChatCompletionRequestMessage from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of function_call
+        if self.function_call:
+            _dict['function_call'] = self.function_call.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatCompletionRequestMessage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "role": obj.get("role"),
+            "content": obj.get("content"),
+            "name": obj.get("name"),
+            "function_call": ChatCompletionRequestMessageFunctionCall.from_dict(obj["function_call"]) if obj.get("function_call") is not None else None
+        })
+        return _obj
+
+

openapiopenai/models/chat_completion_request_message_function_call.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+    OpenAI API
+
+    APIs for sampling from and fine-tuning language models
+
+    The version of the OpenAPI document: 2.0.0
+    Contact: blah+oapicf@cliffano.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatCompletionRequestMessageFunctionCall(BaseModel):
+    """
+    The name and arguments of a function that should be called, as generated by the model.
+    """ # noqa: E501
+    name: Optional[StrictStr] = Field(default=None, description="The name of the function to call.")
+    arguments: Optional[StrictStr] = Field(default=None, description="The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.")
+    __properties: ClassVar[List[str]] = ["name", "arguments"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ChatCompletionRequestMessageFunctionCall from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatCompletionRequestMessageFunctionCall from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "arguments": obj.get("arguments")
+        })
+        return _obj
+
+

openapiopenai/models/chat_completion_response_message.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+"""
+    OpenAI API
+
+    APIs for sampling from and fine-tuning language models
+
+    The version of the OpenAPI document: 2.0.0
+    Contact: blah+oapicf@cliffano.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from openapiopenai.models.chat_completion_request_message_function_call import ChatCompletionRequestMessageFunctionCall
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatCompletionResponseMessage(BaseModel):
+    """
+    ChatCompletionResponseMessage
+    """ # noqa: E501
+    role: StrictStr = Field(description="The role of the author of this message.")
+    content: Optional[StrictStr] = Field(default=None, description="The contents of the message.")
+    function_call: Optional[ChatCompletionRequestMessageFunctionCall] = None
+    __properties: ClassVar[List[str]] = ["role", "content", "function_call"]
+
+    @field_validator('role')
+    def role_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['system', 'user', 'assistant', 'function']):
+            raise ValueError("must be one of enum values ('system', 'user', 'assistant', 'function')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ChatCompletionResponseMessage from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of function_call
+        if self.function_call:
+            _dict['function_call'] = self.function_call.to_dict()
+        # set to None if content (nullable) is None
+        # and model_fields_set contains the field
+        if self.content is None and "content" in self.model_fields_set:
+            _dict['content'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatCompletionResponseMessage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "role": obj.get("role"),
+            "content": obj.get("content"),
+            "function_call": ChatCompletionRequestMessageFunctionCall.from_dict(obj["function_call"]) if obj.get("function_call") is not None else None
+        })
+        return _obj
+
+

openapiopenai/models/chat_completion_stream_response_delta.py

@@ -0,0 +1,111 @@
+# coding: utf-8
+
+"""
+    OpenAI API
+
+    APIs for sampling from and fine-tuning language models
+
+    The version of the OpenAPI document: 2.0.0
+    Contact: blah+oapicf@cliffano.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from openapiopenai.models.chat_completion_request_message_function_call import ChatCompletionRequestMessageFunctionCall
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatCompletionStreamResponseDelta(BaseModel):
+    """
+    ChatCompletionStreamResponseDelta
+    """ # noqa: E501
+    role: Optional[StrictStr] = Field(default=None, description="The role of the author of this message.")
+    content: Optional[StrictStr] = Field(default=None, description="The contents of the chunk message.")
+    function_call: Optional[ChatCompletionRequestMessageFunctionCall] = None
+    __properties: ClassVar[List[str]] = ["role", "content", "function_call"]
+
+    @field_validator('role')
+    def role_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['system', 'user', 'assistant', 'function']):
+            raise ValueError("must be one of enum values ('system', 'user', 'assistant', 'function')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ChatCompletionStreamResponseDelta from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of function_call
+        if self.function_call:
+            _dict['function_call'] = self.function_call.to_dict()
+        # set to None if content (nullable) is None
+        # and model_fields_set contains the field
+        if self.content is None and "content" in self.model_fields_set:
+            _dict['content'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatCompletionStreamResponseDelta from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "role": obj.get("role"),
+            "content": obj.get("content"),
+            "function_call": ChatCompletionRequestMessageFunctionCall.from_dict(obj["function_call"]) if obj.get("function_call") is not None else None
+        })
+        return _obj
+
+