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

everyrow/generated/models/merge_operation.py

@@ -0,0 +1,278 @@
+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 ..models.merge_operation_use_web_search_type_0 import MergeOperationUseWebSearchType0
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.merge_operation_left_input_type_1_item import MergeOperationLeftInputType1Item
+    from ..models.merge_operation_left_input_type_2 import MergeOperationLeftInputType2
+    from ..models.merge_operation_right_input_type_1_item import MergeOperationRightInputType1Item
+    from ..models.merge_operation_right_input_type_2 import MergeOperationRightInputType2
+
+
+T = TypeVar("T", bound="MergeOperation")
+
+
+@_attrs_define
+class MergeOperation:
+    """
+    Attributes:
+        left_input (list[MergeOperationLeftInputType1Item] | MergeOperationLeftInputType2 | UUID): Left input: artifact
+            UUID, list of records, or single record
+        right_input (list[MergeOperationRightInputType1Item] | MergeOperationRightInputType2 | UUID): Right input:
+            artifact UUID, list of records, or single record
+        task (str): Instructions for the AI to determine how to merge rows
+        left_key (None | str | Unset): Column name to merge on from left table
+        right_key (None | str | Unset): Column name to merge on from right table
+        use_web_search (MergeOperationUseWebSearchType0 | None | Unset): Control web search behavior: 'auto' (default)
+            tries LLM merge first then conditionally searches, 'no' skips web search entirely, 'yes' forces web search
+            without initial LLM merge Default: MergeOperationUseWebSearchType0.AUTO.
+        session_id (None | Unset | UUID): Session ID. If not provided, a new session is auto-created for this task.
+    """
+
+    left_input: list[MergeOperationLeftInputType1Item] | MergeOperationLeftInputType2 | UUID
+    right_input: list[MergeOperationRightInputType1Item] | MergeOperationRightInputType2 | UUID
+    task: str
+    left_key: None | str | Unset = UNSET
+    right_key: None | str | Unset = UNSET
+    use_web_search: MergeOperationUseWebSearchType0 | None | Unset = MergeOperationUseWebSearchType0.AUTO
+    session_id: None | Unset | UUID = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        left_input: dict[str, Any] | list[dict[str, Any]] | str
+        if isinstance(self.left_input, UUID):
+            left_input = str(self.left_input)
+        elif isinstance(self.left_input, list):
+            left_input = []
+            for left_input_type_1_item_data in self.left_input:
+                left_input_type_1_item = left_input_type_1_item_data.to_dict()
+                left_input.append(left_input_type_1_item)
+
+        else:
+            left_input = self.left_input.to_dict()
+
+        right_input: dict[str, Any] | list[dict[str, Any]] | str
+        if isinstance(self.right_input, UUID):
+            right_input = str(self.right_input)
+        elif isinstance(self.right_input, list):
+            right_input = []
+            for right_input_type_1_item_data in self.right_input:
+                right_input_type_1_item = right_input_type_1_item_data.to_dict()
+                right_input.append(right_input_type_1_item)
+
+        else:
+            right_input = self.right_input.to_dict()
+
+        task = self.task
+
+        left_key: None | str | Unset
+        if isinstance(self.left_key, Unset):
+            left_key = UNSET
+        else:
+            left_key = self.left_key
+
+        right_key: None | str | Unset
+        if isinstance(self.right_key, Unset):
+            right_key = UNSET
+        else:
+            right_key = self.right_key
+
+        use_web_search: None | str | Unset
+        if isinstance(self.use_web_search, Unset):
+            use_web_search = UNSET
+        elif isinstance(self.use_web_search, MergeOperationUseWebSearchType0):
+            use_web_search = self.use_web_search.value
+        else:
+            use_web_search = self.use_web_search
+
+        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(
+            {
+                "left_input": left_input,
+                "right_input": right_input,
+                "task": task,
+            }
+        )
+        if left_key is not UNSET:
+            field_dict["left_key"] = left_key
+        if right_key is not UNSET:
+            field_dict["right_key"] = right_key
+        if use_web_search is not UNSET:
+            field_dict["use_web_search"] = use_web_search
+        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.merge_operation_left_input_type_1_item import MergeOperationLeftInputType1Item
+        from ..models.merge_operation_left_input_type_2 import MergeOperationLeftInputType2
+        from ..models.merge_operation_right_input_type_1_item import MergeOperationRightInputType1Item
+        from ..models.merge_operation_right_input_type_2 import MergeOperationRightInputType2
+
+        d = dict(src_dict)
+
+        def _parse_left_input(
+            data: object,
+        ) -> list[MergeOperationLeftInputType1Item] | MergeOperationLeftInputType2 | UUID:
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                left_input_type_0 = UUID(data)
+
+                return left_input_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                left_input_type_1 = []
+                _left_input_type_1 = data
+                for left_input_type_1_item_data in _left_input_type_1:
+                    left_input_type_1_item = MergeOperationLeftInputType1Item.from_dict(left_input_type_1_item_data)
+
+                    left_input_type_1.append(left_input_type_1_item)
+
+                return left_input_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            left_input_type_2 = MergeOperationLeftInputType2.from_dict(data)
+
+            return left_input_type_2
+
+        left_input = _parse_left_input(d.pop("left_input"))
+
+        def _parse_right_input(
+            data: object,
+        ) -> list[MergeOperationRightInputType1Item] | MergeOperationRightInputType2 | UUID:
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                right_input_type_0 = UUID(data)
+
+                return right_input_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                right_input_type_1 = []
+                _right_input_type_1 = data
+                for right_input_type_1_item_data in _right_input_type_1:
+                    right_input_type_1_item = MergeOperationRightInputType1Item.from_dict(right_input_type_1_item_data)
+
+                    right_input_type_1.append(right_input_type_1_item)
+
+                return right_input_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            right_input_type_2 = MergeOperationRightInputType2.from_dict(data)
+
+            return right_input_type_2
+
+        right_input = _parse_right_input(d.pop("right_input"))
+
+        task = d.pop("task")
+
+        def _parse_left_key(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        left_key = _parse_left_key(d.pop("left_key", UNSET))
+
+        def _parse_right_key(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        right_key = _parse_right_key(d.pop("right_key", UNSET))
+
+        def _parse_use_web_search(data: object) -> MergeOperationUseWebSearchType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                use_web_search_type_0 = MergeOperationUseWebSearchType0(data)
+
+                return use_web_search_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(MergeOperationUseWebSearchType0 | None | Unset, data)
+
+        use_web_search = _parse_use_web_search(d.pop("use_web_search", UNSET))
+
+        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))
+
+        merge_operation = cls(
+            left_input=left_input,
+            right_input=right_input,
+            task=task,
+            left_key=left_key,
+            right_key=right_key,
+            use_web_search=use_web_search,
+            session_id=session_id,
+        )
+
+        merge_operation.additional_properties = d
+        return merge_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/merge_operation_left_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="MergeOperationLeftInputType1Item")
+
+
+@_attrs_define
+class MergeOperationLeftInputType1Item:
+    """ """
+
+    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)
+        merge_operation_left_input_type_1_item = cls()
+
+        merge_operation_left_input_type_1_item.additional_properties = d
+        return merge_operation_left_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/{chat_completion_message_tool_call.py → merge_operation_left_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="ChatCompletionMessageToolCall")
+T = TypeVar("T", bound="MergeOperationLeftInputType2")
 
 
 @_attrs_define
-class ChatCompletionMessageToolCall:
+class MergeOperationLeftInputType2:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -24,10 +24,10 @@ class ChatCompletionMessageToolCall:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        chat_completion_message_tool_call = cls()
+        merge_operation_left_input_type_2 = cls()
 
-        chat_completion_message_tool_call.additional_properties = d
-        return chat_completion_message_tool_call
+        merge_operation_left_input_type_2.additional_properties = d
+        return merge_operation_left_input_type_2
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/merge_operation_right_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="MergeOperationRightInputType1Item")
+
+
+@_attrs_define
+class MergeOperationRightInputType1Item:
+    """ """
+
+    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)
+        merge_operation_right_input_type_1_item = cls()
+
+        merge_operation_right_input_type_1_item.additional_properties = d
+        return merge_operation_right_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/merge_operation_right_input_type_2.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="MergeOperationRightInputType2")
+
+
+@_attrs_define
+class MergeOperationRightInputType2:
+    """ """
+
+    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)
+        merge_operation_right_input_type_2 = cls()
+
+        merge_operation_right_input_type_2.additional_properties = d
+        return merge_operation_right_input_type_2
+
+    @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/merge_operation_use_web_search_type_0.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MergeOperationUseWebSearchType0(str, Enum):
+    AUTO = "auto"
+    NO = "no"
+    YES = "yes"
+
+    def __str__(self) -> str:
+        return str(self.value)

everyrow/generated/models/operation_response.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.task_status import TaskStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OperationResponse")
+
+
+@_attrs_define
+class OperationResponse:
+    """
+    Attributes:
+        task_id (UUID): The ID of the created task
+        session_id (UUID): The session ID (auto-created if not provided)
+        status (TaskStatus):
+        artifact_id (None | Unset | UUID): Result artifact ID (available when completed)
+        error (None | str | Unset): Error message (available when failed)
+    """
+
+    task_id: UUID
+    session_id: UUID
+    status: TaskStatus
+    artifact_id: None | Unset | UUID = UNSET
+    error: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        task_id = str(self.task_id)
+
+        session_id = str(self.session_id)
+
+        status = self.status.value
+
+        artifact_id: None | str | Unset
+        if isinstance(self.artifact_id, Unset):
+            artifact_id = UNSET
+        elif isinstance(self.artifact_id, UUID):
+            artifact_id = str(self.artifact_id)
+        else:
+            artifact_id = self.artifact_id
+
+        error: None | str | Unset
+        if isinstance(self.error, Unset):
+            error = UNSET
+        else:
+            error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "task_id": task_id,
+                "session_id": session_id,
+                "status": status,
+            }
+        )
+        if artifact_id is not UNSET:
+            field_dict["artifact_id"] = artifact_id
+        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)
+        task_id = UUID(d.pop("task_id"))
+
+        session_id = UUID(d.pop("session_id"))
+
+        status = TaskStatus(d.pop("status"))
+
+        def _parse_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()
+                artifact_id_type_0 = UUID(data)
+
+                return artifact_id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        artifact_id = _parse_artifact_id(d.pop("artifact_id", UNSET))
+
+        def _parse_error(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        error = _parse_error(d.pop("error", UNSET))
+
+        operation_response = cls(
+            task_id=task_id,
+            session_id=session_id,
+            status=status,
+            artifact_id=artifact_id,
+            error=error,
+        )
+
+        operation_response.additional_properties = d
+        return operation_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/{multi_agent_effort_level.py → public_effort_level.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class MultiAgentEffortLevel(str, Enum):
+class PublicEffortLevel(str, Enum):
     HIGH = "high"
     LOW = "low"
     MEDIUM = "medium"

everyrow/generated/models/public_task_type.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class PublicTaskType(str, Enum):
+    AGENT = "agent"
+    DEDUPE = "dedupe"
+    MERGE = "merge"
+    RANK = "rank"
+    SCREEN = "screen"
+
+    def __str__(self) -> str:
+        return str(self.value)