camb-sdk 1.0.0__py3-none-any.whl

cambai/models/create_tts_stream_request_payload.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+    FastAPI
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from cambai.models.gender import Gender
+from cambai.models.languages import Languages
+from cambai.models.tts_stream_output_format import TTSStreamOutputFormat
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateTTSStreamRequestPayload(BaseModel):
+    """
+    CreateTTSStreamRequestPayload
+    """ # noqa: E501
+    text: StrictStr = Field(description="The content you want converted into spoken audio. This can be anything from a single sentence to paragraphs of text, supporting punctuation for natural speech patterns.")
+    voice_id: StrictInt = Field(description="The unique identifier for your selected voice profile. You can obtain available voice IDs from the `/list-voices` endpoint or create custom voices with the `/create-custom-voice` endpoint.")
+    language: Languages = Field(description="The source language of your input text. This helps the system apply the correct pronunciation rules and speech patterns.")
+    gender: Optional[Gender] = Field(default=None, description="The preferred gender characteristics of the synthesized voice (`0 = Not Specified, 1 = Male, 2 = Female, 9 = Not Applicable`). Defaults to `null`.")
+    age: Optional[StrictInt] = Field(default=None, description="The approximate age (between 1-100 years) to be reflected in the voice characteristics. This parameter helps fine-tune the timbre and speech patterns to match different age groups.")
+    output_format: Optional[TTSStreamOutputFormat] = Field(default=None, description="The audio file format for the generated speech stream.")
+    __properties: ClassVar[List[str]] = ["text", "voice_id", "language", "gender", "age", "output_format"]
+
+    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 CreateTTSStreamRequestPayload 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 CreateTTSStreamRequestPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "text": obj.get("text"),
+            "voice_id": obj.get("voice_id"),
+            "language": obj.get("language"),
+            "gender": obj.get("gender"),
+            "age": obj.get("age"),
+            "output_format": obj.get("output_format")
+        })
+        return _obj
+
+

cambai/models/dialogue_item.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    FastAPI
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DialogueItem(BaseModel):
+    """
+    A JSON that represents a single piece of dialogue or speech within a given time range. It includes details about the timing (start and end), the content of the dialogue (text), and the speaker who delivers the dialogue
+    """ # noqa: E501
+    start: Union[StrictFloat, StrictInt] = Field(description="The start time (in seconds) of the dialogue.")
+    end: Union[StrictFloat, StrictInt] = Field(description="The end time (in seconds) of the dialogue.")
+    text: StrictStr = Field(description="The actual text content of the dialogue spoken by the speaker.")
+    speaker: StrictStr = Field(description="The name or identifier of the speaker delivering the dialogue.")
+    __properties: ClassVar[List[str]] = ["start", "end", "text", "speaker"]
+
+    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 DialogueItem 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 DialogueItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "start": obj.get("start"),
+            "end": obj.get("end"),
+            "text": obj.get("text"),
+            "speaker": obj.get("speaker")
+        })
+        return _obj
+
+

cambai/models/dictionary.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    FastAPI
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Dictionary(BaseModel):
+    """
+    Dictionary
+    """ # noqa: E501
+    id: Optional[StrictInt] = Field(default=None, description="The unique identifier of the dictionary.")
+    name: Optional[StrictStr] = Field(default=None, description="The name of the dictionary.")
+    description: Optional[StrictStr] = Field(default=None, description="A brief description of the dictionary.")
+    created_at: Optional[datetime] = Field(default=None, description="The date and time when the dictionary was created.")
+    updated_at: Optional[datetime] = Field(default=None, description="The date and time when the dictionary was last updated.")
+    __properties: ClassVar[List[str]] = ["id", "name", "description", "created_at", "updated_at"]
+
+    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 Dictionary 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 Dictionary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "created_at": obj.get("created_at"),
+            "updated_at": obj.get("updated_at")
+        })
+        return _obj
+
+

cambai/models/dub_alt_format_response_body.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    FastAPI
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DubAltFormatResponseBody(BaseModel):
+    """
+    DubAltFormatResponseBody
+    """ # noqa: E501
+    output_url: Optional[Any] = None
+    __properties: ClassVar[List[str]] = ["output_url"]
+
+    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 DubAltFormatResponseBody 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,
+        )
+        # set to None if output_url (nullable) is None
+        # and model_fields_set contains the field
+        if self.output_url is None and "output_url" in self.model_fields_set:
+            _dict['output_url'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DubAltFormatResponseBody from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "output_url": obj.get("output_url")
+        })
+        return _obj
+
+

cambai/models/dubbed_output_in_alt_format_request_payload.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    FastAPI
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    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
+from typing import Any, ClassVar, Dict, List
+from cambai.models.output_format import OutputFormat
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DubbedOutputInAltFormatRequestPayload(BaseModel):
+    """
+    DubbedOutputInAltFormatRequestPayload
+    """ # noqa: E501
+    output_format: OutputFormat
+    __properties: ClassVar[List[str]] = ["output_format"]
+
+    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 DubbedOutputInAltFormatRequestPayload 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 output_format
+        if self.output_format:
+            _dict['output_format'] = self.output_format.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DubbedOutputInAltFormatRequestPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "output_format": OutputFormat.from_dict(obj["output_format"]) if obj.get("output_format") is not None else None
+        })
+        return _obj
+
+

cambai/models/end_to_end_dubbing_request_payload.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    FastAPI
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    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, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from cambai.models.languages import Languages
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EndToEndDubbingRequestPayload(BaseModel):
+    """
+    EndToEndDubbingRequestPayload
+    """ # noqa: E501
+    video_url: StrictStr = Field(description="The URL of the media file to be used to create the end-to-end dubbing task.")
+    source_language: Languages = Field(description="The original language of the media file to be used to create the end-to-end dubbing task.")
+    target_languages: Optional[List[Languages]] = Field(default=None, description="The list of desired languages that the media file will be dubbed to.")
+    selected_audio_tracks: Optional[Annotated[List[Optional[StrictInt]], Field(min_length=1, max_length=2)]] = Field(default=None, description="Optional array of one or two zero‑based audio track indices to dub. Only supported for `MXF` files. If omitted, the first audio track (index 0) is used by default.")
+    add_output_as_an_audio_track: Optional[StrictBool] = Field(default=None, description="Optional flag to append the dubbed audio as a new audio track in the output file. Only supported for `MXF` files. If `true`, the dubbed audio is added as an additional track; if `false` or omitted, the source would be returned with only dubbed audio.")
+    chosen_dictionaries: Optional[Annotated[List[StrictInt], Field(min_length=1)]] = Field(default=None, description="An optional list of dictionary IDs selected by the user. Each entry must be an integer corresponding to a valid dictionary ID. If provided, at least one ID is required.")
+    __properties: ClassVar[List[str]] = ["video_url", "source_language", "target_languages", "selected_audio_tracks", "add_output_as_an_audio_track", "chosen_dictionaries"]
+
+    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 EndToEndDubbingRequestPayload 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 EndToEndDubbingRequestPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "video_url": obj.get("video_url"),
+            "source_language": obj.get("source_language"),
+            "target_languages": obj.get("target_languages"),
+            "selected_audio_tracks": obj.get("selected_audio_tracks"),
+            "add_output_as_an_audio_track": obj.get("add_output_as_an_audio_track"),
+            "chosen_dictionaries": obj.get("chosen_dictionaries")
+        })
+        return _obj
+
+

cambai/models/expire_api_key_request_payload.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    FastAPI
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    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, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ExpireAPIKeyRequestPayload(BaseModel):
+    """
+    ExpireAPIKeyRequestPayload
+    """ # noqa: E501
+    api_key_id: StrictInt
+    __properties: ClassVar[List[str]] = ["api_key_id"]
+
+    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 ExpireAPIKeyRequestPayload 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 ExpireAPIKeyRequestPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "api_key_id": obj.get("api_key_id")
+        })
+        return _obj
+
+