everyrow 0.1.0__py3-none-any.whl

everyrow/generated/models/import_from_google_sheets_import_post_response_import_from_google_sheets_import_post.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ImportFromGoogleSheetsImportPostResponseImportFromGoogleSheetsImportPost")
+
+
+@_attrs_define
+class ImportFromGoogleSheetsImportPostResponseImportFromGoogleSheetsImportPost:
+    """ """
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        import_from_google_sheets_import_post_response_import_from_google_sheets_import_post = cls()
+
+        import_from_google_sheets_import_post_response_import_from_google_sheets_import_post.additional_properties = d
+        return import_from_google_sheets_import_post_response_import_from_google_sheets_import_post
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

everyrow/generated/models/import_request.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.import_request_token_data import ImportRequestTokenData
+
+
+T = TypeVar("T", bound="ImportRequest")
+
+
+@_attrs_define
+class ImportRequest:
+    """
+    Attributes:
+        session_id (str):
+        token_data (ImportRequestTokenData):
+        sheets_url (str):
+    """
+
+    session_id: str
+    token_data: ImportRequestTokenData
+    sheets_url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        session_id = self.session_id
+
+        token_data = self.token_data.to_dict()
+
+        sheets_url = self.sheets_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "session_id": session_id,
+                "token_data": token_data,
+                "sheets_url": sheets_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.import_request_token_data import ImportRequestTokenData
+
+        d = dict(src_dict)
+        session_id = d.pop("session_id")
+
+        token_data = ImportRequestTokenData.from_dict(d.pop("token_data"))
+
+        sheets_url = d.pop("sheets_url")
+
+        import_request = cls(
+            session_id=session_id,
+            token_data=token_data,
+            sheets_url=sheets_url,
+        )
+
+        import_request.additional_properties = d
+        return import_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

everyrow/generated/models/import_request_token_data.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ImportRequestTokenData")
+
+
+@_attrs_define
+class ImportRequestTokenData:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        import_request_token_data = cls()
+
+        import_request_token_data.additional_properties = d
+        return import_request_token_data
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

everyrow/generated/models/insufficient_balance_error.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InsufficientBalanceError")
+
+
+@_attrs_define
+class InsufficientBalanceError:
+    """Error response when user has insufficient balance for usage-based billing.
+
+    Attributes:
+        message (str):
+        current_balance_dollars (float):
+        error (str | Unset):  Default: 'INSUFFICIENT_BALANCE'.
+    """
+
+    message: str
+    current_balance_dollars: float
+    error: str | Unset = "INSUFFICIENT_BALANCE"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        current_balance_dollars = self.current_balance_dollars
+
+        error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "message": message,
+                "current_balance_dollars": current_balance_dollars,
+            }
+        )
+        if error is not UNSET:
+            field_dict["error"] = error
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        message = d.pop("message")
+
+        current_balance_dollars = d.pop("current_balance_dollars")
+
+        error = d.pop("error", UNSET)
+
+        insufficient_balance_error = cls(
+            message=message,
+            current_balance_dollars=current_balance_dollars,
+            error=error,
+        )
+
+        insufficient_balance_error.additional_properties = d
+        return insufficient_balance_error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

everyrow/generated/models/join_query_params.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="JoinQueryParams")
+
+
+@_attrs_define
+class JoinQueryParams:
+    """
+    Attributes:
+        join_fields (list[str]):
+        auto_detect_join_fields (bool | Unset): When true, automatically detect all columns with matching values to join
+            on. When enabled, join_fields is ignored. Default: False.
+    """
+
+    join_fields: list[str]
+    auto_detect_join_fields: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        join_fields = self.join_fields
+
+        auto_detect_join_fields = self.auto_detect_join_fields
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "join_fields": join_fields,
+            }
+        )
+        if auto_detect_join_fields is not UNSET:
+            field_dict["auto_detect_join_fields"] = auto_detect_join_fields
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        join_fields = cast(list[str], d.pop("join_fields"))
+
+        auto_detect_join_fields = d.pop("auto_detect_join_fields", UNSET)
+
+        join_query_params = cls(
+            join_fields=join_fields,
+            auto_detect_join_fields=auto_detect_join_fields,
+        )
+
+        join_query_params.additional_properties = d
+        return join_query_params
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

everyrow/generated/models/join_request.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.join_query_params import JoinQueryParams
+
+
+T = TypeVar("T", bound="JoinRequest")
+
+
+@_attrs_define
+class JoinRequest:
+    """Request to join artifacts from multiple groups based on a common field.
+
+    Attributes:
+        query (JoinQueryParams):
+        input_artifacts (list[UUID] | None | Unset):
+        context_artifacts (list[UUID] | None | Unset):
+        label (None | str | Unset): Short task label for use in the UI
+        description (None | str | Unset): Task description for use in the UI
+        task_id (None | Unset | UUID):
+        replaces_task_id (None | Unset | UUID): The ID of the task that this task replaces. Used e.g. by the full
+            version of a task that replaces a preview version.
+        twin_artifact_id (None | Unset | UUID): The ID of a reference artifact, e.g. the right table in Deep Merge
+            operation.
+        task_type (Literal['join'] | Unset):  Default: 'join'.
+        processing_mode (Literal['transform'] | Unset):  Default: 'transform'.
+    """
+
+    query: JoinQueryParams
+    input_artifacts: list[UUID] | None | Unset = UNSET
+    context_artifacts: list[UUID] | None | Unset = UNSET
+    label: None | str | Unset = UNSET
+    description: None | str | Unset = UNSET
+    task_id: None | Unset | UUID = UNSET
+    replaces_task_id: None | Unset | UUID = UNSET
+    twin_artifact_id: None | Unset | UUID = UNSET
+    task_type: Literal["join"] | Unset = "join"
+    processing_mode: Literal["transform"] | Unset = "transform"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query.to_dict()
+
+        input_artifacts: list[str] | None | Unset
+        if isinstance(self.input_artifacts, Unset):
+            input_artifacts = UNSET
+        elif isinstance(self.input_artifacts, list):
+            input_artifacts = []
+            for componentsschemas_input_artifacts_ids_item_data in self.input_artifacts:
+                componentsschemas_input_artifacts_ids_item = str(componentsschemas_input_artifacts_ids_item_data)
+                input_artifacts.append(componentsschemas_input_artifacts_ids_item)
+
+        else:
+            input_artifacts = self.input_artifacts
+
+        context_artifacts: list[str] | None | Unset
+        if isinstance(self.context_artifacts, Unset):
+            context_artifacts = UNSET
+        elif isinstance(self.context_artifacts, list):
+            context_artifacts = []
+            for componentsschemas_context_artifacts_ids_item_data in self.context_artifacts:
+                componentsschemas_context_artifacts_ids_item = str(componentsschemas_context_artifacts_ids_item_data)
+                context_artifacts.append(componentsschemas_context_artifacts_ids_item)
+
+        else:
+            context_artifacts = self.context_artifacts
+
+        label: None | str | Unset
+        if isinstance(self.label, Unset):
+            label = UNSET
+        else:
+            label = self.label
+
+        description: None | str | Unset
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        task_id: None | str | Unset
+        if isinstance(self.task_id, Unset):
+            task_id = UNSET
+        elif isinstance(self.task_id, UUID):
+            task_id = str(self.task_id)
+        else:
+            task_id = self.task_id
+
+        replaces_task_id: None | str | Unset
+        if isinstance(self.replaces_task_id, Unset):
+            replaces_task_id = UNSET
+        elif isinstance(self.replaces_task_id, UUID):
+            replaces_task_id = str(self.replaces_task_id)
+        else:
+            replaces_task_id = self.replaces_task_id
+
+        twin_artifact_id: None | str | Unset
+        if isinstance(self.twin_artifact_id, Unset):
+            twin_artifact_id = UNSET
+        elif isinstance(self.twin_artifact_id, UUID):
+            twin_artifact_id = str(self.twin_artifact_id)
+        else:
+            twin_artifact_id = self.twin_artifact_id
+
+        task_type = self.task_type
+
+        processing_mode = self.processing_mode
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "query": query,
+            }
+        )
+        if input_artifacts is not UNSET:
+            field_dict["input_artifacts"] = input_artifacts
+        if context_artifacts is not UNSET:
+            field_dict["context_artifacts"] = context_artifacts
+        if label is not UNSET:
+            field_dict["label"] = label
+        if description is not UNSET:
+            field_dict["description"] = description
+        if task_id is not UNSET:
+            field_dict["task_id"] = task_id
+        if replaces_task_id is not UNSET:
+            field_dict["replaces_task_id"] = replaces_task_id
+        if twin_artifact_id is not UNSET:
+            field_dict["twin_artifact_id"] = twin_artifact_id
+        if task_type is not UNSET:
+            field_dict["task_type"] = task_type
+        if processing_mode is not UNSET:
+            field_dict["processing_mode"] = processing_mode
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.join_query_params import JoinQueryParams
+
+        d = dict(src_dict)
+        query = JoinQueryParams.from_dict(d.pop("query"))
+
+        def _parse_input_artifacts(data: object) -> list[UUID] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                input_artifacts_type_0 = []
+                _input_artifacts_type_0 = data
+                for componentsschemas_input_artifacts_ids_item_data in _input_artifacts_type_0:
+                    componentsschemas_input_artifacts_ids_item = UUID(componentsschemas_input_artifacts_ids_item_data)
+
+                    input_artifacts_type_0.append(componentsschemas_input_artifacts_ids_item)
+
+                return input_artifacts_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[UUID] | None | Unset, data)
+
+        input_artifacts = _parse_input_artifacts(d.pop("input_artifacts", UNSET))
+
+        def _parse_context_artifacts(data: object) -> list[UUID] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                context_artifacts_type_0 = []
+                _context_artifacts_type_0 = data
+                for componentsschemas_context_artifacts_ids_item_data in _context_artifacts_type_0:
+                    componentsschemas_context_artifacts_ids_item = UUID(
+                        componentsschemas_context_artifacts_ids_item_data
+                    )
+
+                    context_artifacts_type_0.append(componentsschemas_context_artifacts_ids_item)
+
+                return context_artifacts_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[UUID] | None | Unset, data)
+
+        context_artifacts = _parse_context_artifacts(d.pop("context_artifacts", UNSET))
+
+        def _parse_label(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        label = _parse_label(d.pop("label", UNSET))
+
+        def _parse_description(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        def _parse_task_id(data: object) -> None | Unset | UUID:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                task_id_type_0 = UUID(data)
+
+                return task_id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        task_id = _parse_task_id(d.pop("task_id", UNSET))
+
+        def _parse_replaces_task_id(data: object) -> None | Unset | UUID:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                replaces_task_id_type_0 = UUID(data)
+
+                return replaces_task_id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        replaces_task_id = _parse_replaces_task_id(d.pop("replaces_task_id", UNSET))
+
+        def _parse_twin_artifact_id(data: object) -> None | Unset | UUID:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                twin_artifact_id_type_0 = UUID(data)
+
+                return twin_artifact_id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        twin_artifact_id = _parse_twin_artifact_id(d.pop("twin_artifact_id", UNSET))
+
+        task_type = cast(Literal["join"] | Unset, d.pop("task_type", UNSET))
+        if task_type != "join" and not isinstance(task_type, Unset):
+            raise ValueError(f"task_type must match const 'join', got '{task_type}'")
+
+        processing_mode = cast(Literal["transform"] | Unset, d.pop("processing_mode", UNSET))
+        if processing_mode != "transform" and not isinstance(processing_mode, Unset):
+            raise ValueError(f"processing_mode must match const 'transform', got '{processing_mode}'")
+
+        join_request = cls(
+            query=query,
+            input_artifacts=input_artifacts,
+            context_artifacts=context_artifacts,
+            label=label,
+            description=description,
+            task_id=task_id,
+            replaces_task_id=replaces_task_id,
+            twin_artifact_id=twin_artifact_id,
+            task_type=task_type,
+            processing_mode=processing_mode,
+        )
+
+        join_request.additional_properties = d
+        return join_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

everyrow/generated/models/llm_enum.py

@@ -0,0 +1,54 @@
+from enum import Enum
+
+
+class LLMEnum(str, Enum):
+    AUTOCOHORT_MODEL = "AUTOCOHORT_MODEL"
+    CLAUDE_3_7_SONNET = "CLAUDE_3_7_SONNET"
+    CLAUDE_3_7_SONNET_THINKING = "CLAUDE_3_7_SONNET_THINKING"
+    CLAUDE_4_1_OPUS = "CLAUDE_4_1_OPUS"
+    CLAUDE_4_1_OPUS_THINKING = "CLAUDE_4_1_OPUS_THINKING"
+    CLAUDE_4_5_HAIKU = "CLAUDE_4_5_HAIKU"
+    CLAUDE_4_5_HAIKU_MINIMAL = "CLAUDE_4_5_HAIKU_MINIMAL"
+    CLAUDE_4_5_HAIKU_THINKING = "CLAUDE_4_5_HAIKU_THINKING"
+    CLAUDE_4_5_OPUS = "CLAUDE_4_5_OPUS"
+    CLAUDE_4_5_OPUS_HIGH = "CLAUDE_4_5_OPUS_HIGH"
+    CLAUDE_4_5_OPUS_LOW = "CLAUDE_4_5_OPUS_LOW"
+    CLAUDE_4_5_OPUS_THINKING = "CLAUDE_4_5_OPUS_THINKING"
+    CLAUDE_4_5_SONNET = "CLAUDE_4_5_SONNET"
+    CLAUDE_4_5_SONNET_HIGH = "CLAUDE_4_5_SONNET_HIGH"
+    CLAUDE_4_5_SONNET_MINIMAL = "CLAUDE_4_5_SONNET_MINIMAL"
+    CLAUDE_4_5_SONNET_THINKING = "CLAUDE_4_5_SONNET_THINKING"
+    CLAUDE_4_OPUS = "CLAUDE_4_OPUS"
+    CLAUDE_4_OPUS_THINKING = "CLAUDE_4_OPUS_THINKING"
+    CLAUDE_4_SONNET = "CLAUDE_4_SONNET"
+    CLAUDE_4_SONNET_THINKING = "CLAUDE_4_SONNET_THINKING"
+    DEEPSEEK_R1_0528 = "DEEPSEEK_R1_0528"
+    DEFAULT_LARGE = "DEFAULT_LARGE"
+    DEFAULT_SMALL = "DEFAULT_SMALL"
+    GEMINI_2_5_FLASH = "GEMINI_2_5_FLASH"
+    GEMINI_2_5_FLASH_LITE = "GEMINI_2_5_FLASH_LITE"
+    GEMINI_2_5_FLASH_THINKING = "GEMINI_2_5_FLASH_THINKING"
+    GEMINI_2_5_PRO = "GEMINI_2_5_PRO"
+    GEMINI_3_FLASH_HIGH = "GEMINI_3_FLASH_HIGH"
+    GEMINI_3_FLASH_LOW = "GEMINI_3_FLASH_LOW"
+    GEMINI_3_FLASH_MEDIUM = "GEMINI_3_FLASH_MEDIUM"
+    GEMINI_3_FLASH_MINIMAL = "GEMINI_3_FLASH_MINIMAL"
+    GEMINI_3_PREVIEW_HIGH = "GEMINI_3_PREVIEW_HIGH"
+    GEMINI_3_PREVIEW_LOW = "GEMINI_3_PREVIEW_LOW"
+    GEMINI_3_PREVIEW_MEDIUM = "GEMINI_3_PREVIEW_MEDIUM"
+    GPT_5 = "GPT_5"
+    GPT_5_1_LOW = "GPT_5_1_LOW"
+    GPT_5_1_NT = "GPT_5_1_NT"
+    GPT_5_2_LOW = "GPT_5_2_LOW"
+    GPT_5_2_NT = "GPT_5_2_NT"
+    GPT_5_HIGH = "GPT_5_HIGH"
+    GPT_5_LOW = "GPT_5_LOW"
+    GPT_5_MINI = "GPT_5_MINI"
+    GPT_5_MINIMAL = "GPT_5_MINIMAL"
+    GPT_5_NANO = "GPT_5_NANO"
+    GROK_4 = "GROK_4"
+    O3 = "O3"
+    O3_MINI = "O3_MINI"
+
+    def __str__(self) -> str:
+        return str(self.value)