everyrow 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

everyrow/generated/models/{task_metadata_cols_to_rename_type_0.py → create_artifact_request_data_type_1.py}

@@ -6,11 +6,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="TaskMetadataColsToRenameType0")
+T = TypeVar("T", bound="CreateArtifactRequestDataType1")
 
 
 @_attrs_define
-class TaskMetadataColsToRenameType0:
+class CreateArtifactRequestDataType1:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -24,10 +24,10 @@ class TaskMetadataColsToRenameType0:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        task_metadata_cols_to_rename_type_0 = cls()
+        create_artifact_request_data_type_1 = cls()
 
-        task_metadata_cols_to_rename_type_0.additional_properties = d
-        return task_metadata_cols_to_rename_type_0
+        create_artifact_request_data_type_1.additional_properties = d
+        return create_artifact_request_data_type_1
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/{copy_artifacts_response.py → create_artifact_response.py}

@@ -7,32 +7,32 @@ from uuid import UUID
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="CopyArtifactsResponse")
+T = TypeVar("T", bound="CreateArtifactResponse")
 
 
 @_attrs_define
-class CopyArtifactsResponse:
+class CreateArtifactResponse:
     """
     Attributes:
-        artifact_id (UUID):
-        task_id (UUID):
+        artifact_id (UUID): The ID of the created artifact
+        session_id (UUID): The session ID (auto-created if not provided)
     """
 
     artifact_id: UUID
-    task_id: UUID
+    session_id: UUID
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         artifact_id = str(self.artifact_id)
 
-        task_id = str(self.task_id)
+        session_id = str(self.session_id)
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
                 "artifact_id": artifact_id,
-                "task_id": task_id,
+                "session_id": session_id,
             }
         )
 
@@ -43,15 +43,15 @@ class CopyArtifactsResponse:
         d = dict(src_dict)
         artifact_id = UUID(d.pop("artifact_id"))
 
-        task_id = UUID(d.pop("task_id"))
+        session_id = UUID(d.pop("session_id"))
 
-        copy_artifacts_response = cls(
+        create_artifact_response = cls(
             artifact_id=artifact_id,
-            task_id=task_id,
+            session_id=session_id,
         )
 
-        copy_artifacts_response.additional_properties = d
-        return copy_artifacts_response
+        create_artifact_response.additional_properties = d
+        return create_artifact_response
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/{create_session_request.py → create_session.py}

@@ -6,13 +6,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="CreateSessionRequest")
+T = TypeVar("T", bound="CreateSession")
 
 
 @_attrs_define
-class CreateSessionRequest:
-    """Request to create a new session.
-
+class CreateSession:
+    """
     Attributes:
         name (str): Name of the session
     """
@@ -38,12 +37,12 @@ class CreateSessionRequest:
         d = dict(src_dict)
         name = d.pop("name")
 
-        create_session_request = cls(
+        create_session = cls(
             name=name,
         )
 
-        create_session_request.additional_properties = d
-        return create_session_request
+        create_session.additional_properties = d
+        return create_session
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/dedupe_operation.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, 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.dedupe_operation_input_type_1_item import DedupeOperationInputType1Item
+    from ..models.dedupe_operation_input_type_2 import DedupeOperationInputType2
+
+
+T = TypeVar("T", bound="DedupeOperation")
+
+
+@_attrs_define
+class DedupeOperation:
+    """
+    Attributes:
+        input_ (DedupeOperationInputType2 | list[DedupeOperationInputType1Item] | UUID): The input data as a) the ID of
+            an existing artifact, b) a single record in the form of a JSON object, or c) a table of records in the form of a
+            list of JSON objects
+        equivalence_relation (str): Description of what makes two rows equivalent/duplicates
+        session_id (None | Unset | UUID): Session ID. If not provided, a new session is auto-created for this task.
+    """
+
+    input_: DedupeOperationInputType2 | list[DedupeOperationInputType1Item] | UUID
+    equivalence_relation: str
+    session_id: None | Unset | UUID = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        input_: dict[str, Any] | list[dict[str, Any]] | str
+        if isinstance(self.input_, UUID):
+            input_ = str(self.input_)
+        elif isinstance(self.input_, list):
+            input_ = []
+            for input_type_1_item_data in self.input_:
+                input_type_1_item = input_type_1_item_data.to_dict()
+                input_.append(input_type_1_item)
+
+        else:
+            input_ = self.input_.to_dict()
+
+        equivalence_relation = self.equivalence_relation
+
+        session_id: None | str | Unset
+        if isinstance(self.session_id, Unset):
+            session_id = UNSET
+        elif isinstance(self.session_id, UUID):
+            session_id = str(self.session_id)
+        else:
+            session_id = self.session_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "input": input_,
+                "equivalence_relation": equivalence_relation,
+            }
+        )
+        if session_id is not UNSET:
+            field_dict["session_id"] = session_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.dedupe_operation_input_type_1_item import DedupeOperationInputType1Item
+        from ..models.dedupe_operation_input_type_2 import DedupeOperationInputType2
+
+        d = dict(src_dict)
+
+        def _parse_input_(data: object) -> DedupeOperationInputType2 | list[DedupeOperationInputType1Item] | UUID:
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                input_type_0 = UUID(data)
+
+                return input_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                input_type_1 = []
+                _input_type_1 = data
+                for input_type_1_item_data in _input_type_1:
+                    input_type_1_item = DedupeOperationInputType1Item.from_dict(input_type_1_item_data)
+
+                    input_type_1.append(input_type_1_item)
+
+                return input_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            input_type_2 = DedupeOperationInputType2.from_dict(data)
+
+            return input_type_2
+
+        input_ = _parse_input_(d.pop("input"))
+
+        equivalence_relation = d.pop("equivalence_relation")
+
+        def _parse_session_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()
+                session_id_type_0 = UUID(data)
+
+                return session_id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        session_id = _parse_session_id(d.pop("session_id", UNSET))
+
+        dedupe_operation = cls(
+            input_=input_,
+            equivalence_relation=equivalence_relation,
+            session_id=session_id,
+        )
+
+        dedupe_operation.additional_properties = d
+        return dedupe_operation
+
+    @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/dedupe_operation_input_type_1_item.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="DedupeOperationInputType1Item")
+
+
+@_attrs_define
+class DedupeOperationInputType1Item:
+    """ """
+
+    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)
+        dedupe_operation_input_type_1_item = cls()
+
+        dedupe_operation_input_type_1_item.additional_properties = d
+        return dedupe_operation_input_type_1_item
+
+    @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 → dedupe_operation_input_type_2.py}

@@ -6,11 +6,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="ImportRequestTokenData")
+T = TypeVar("T", bound="DedupeOperationInputType2")
 
 
 @_attrs_define
-class ImportRequestTokenData:
+class DedupeOperationInputType2:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -24,10 +24,10 @@ class ImportRequestTokenData:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        import_request_token_data = cls()
+        dedupe_operation_input_type_2 = cls()
 
-        import_request_token_data.additional_properties = d
-        return import_request_token_data
+        dedupe_operation_input_type_2.additional_properties = d
+        return dedupe_operation_input_type_2
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/error_response.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.error_response_details_type_0 import ErrorResponseDetailsType0
+
+
+T = TypeVar("T", bound="ErrorResponse")
+
+
+@_attrs_define
+class ErrorResponse:
+    """
+    Attributes:
+        error_code (str): Machine-readable error code
+        message (str): Human-readable error message
+        details (ErrorResponseDetailsType0 | None | Unset): Additional error details
+    """
+
+    error_code: str
+    message: str
+    details: ErrorResponseDetailsType0 | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.error_response_details_type_0 import ErrorResponseDetailsType0
+
+        error_code = self.error_code
+
+        message = self.message
+
+        details: dict[str, Any] | None | Unset
+        if isinstance(self.details, Unset):
+            details = UNSET
+        elif isinstance(self.details, ErrorResponseDetailsType0):
+            details = self.details.to_dict()
+        else:
+            details = self.details
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error_code": error_code,
+                "message": message,
+            }
+        )
+        if details is not UNSET:
+            field_dict["details"] = details
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.error_response_details_type_0 import ErrorResponseDetailsType0
+
+        d = dict(src_dict)
+        error_code = d.pop("error_code")
+
+        message = d.pop("message")
+
+        def _parse_details(data: object) -> ErrorResponseDetailsType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                details_type_0 = ErrorResponseDetailsType0.from_dict(data)
+
+                return details_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ErrorResponseDetailsType0 | None | Unset, data)
+
+        details = _parse_details(d.pop("details", UNSET))
+
+        error_response = cls(
+            error_code=error_code,
+            message=message,
+            details=details,
+        )
+
+        error_response.additional_properties = d
+        return error_response
+
+    @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/{task_insert_query_params.py → error_response_details_type_0.py}

@@ -6,11 +6,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="TaskInsertQueryParams")
+T = TypeVar("T", bound="ErrorResponseDetailsType0")
 
 
 @_attrs_define
-class TaskInsertQueryParams:
+class ErrorResponseDetailsType0:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -24,10 +24,10 @@ class TaskInsertQueryParams:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        task_insert_query_params = cls()
+        error_response_details_type_0 = cls()
 
-        task_insert_query_params.additional_properties = d
-        return task_insert_query_params
+        error_response_details_type_0.additional_properties = d
+        return error_response_details_type_0
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/insufficient_balance_error.py

@@ -18,11 +18,13 @@ class InsufficientBalanceError:
     Attributes:
         message (str):
         current_balance_dollars (float):
+        minimum_required_dollars (float):
         error (str | Unset):  Default: 'INSUFFICIENT_BALANCE'.
     """
 
     message: str
     current_balance_dollars: float
+    minimum_required_dollars: float
     error: str | Unset = "INSUFFICIENT_BALANCE"
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -31,6 +33,8 @@ class InsufficientBalanceError:
 
         current_balance_dollars = self.current_balance_dollars
 
+        minimum_required_dollars = self.minimum_required_dollars
+
         error = self.error
 
         field_dict: dict[str, Any] = {}
@@ -39,6 +43,7 @@ class InsufficientBalanceError:
             {
                 "message": message,
                 "current_balance_dollars": current_balance_dollars,
+                "minimum_required_dollars": minimum_required_dollars,
             }
         )
         if error is not UNSET:
@@ -53,11 +58,14 @@ class InsufficientBalanceError:
 
         current_balance_dollars = d.pop("current_balance_dollars")
 
+        minimum_required_dollars = d.pop("minimum_required_dollars")
+
         error = d.pop("error", UNSET)
 
         insufficient_balance_error = cls(
             message=message,
             current_balance_dollars=current_balance_dollars,
+            minimum_required_dollars=minimum_required_dollars,
             error=error,
         )
 

everyrow/generated/models/{llm_enum.py → llm_enum_public.py}

@@ -1,12 +1,7 @@
 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"
+class LLMEnumPublic(str, Enum):
     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"
@@ -18,17 +13,6 @@ class LLMEnum(str, Enum):
     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"
@@ -46,9 +30,6 @@ class LLMEnum(str, Enum):
     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)