everyrow 0.1.0__py3-none-any.whl

everyrow/generated/models/date_cutoffs.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DateCutoffs")
+
+
+@_attrs_define
+class DateCutoffs:
+    """
+    Attributes:
+        start (datetime.datetime | None | Unset):
+        end (datetime.datetime | None | Unset):
+        present_date (datetime.datetime | None | Unset):
+    """
+
+    start: datetime.datetime | None | Unset = UNSET
+    end: datetime.datetime | None | Unset = UNSET
+    present_date: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        start: None | str | Unset
+        if isinstance(self.start, Unset):
+            start = UNSET
+        elif isinstance(self.start, datetime.datetime):
+            start = self.start.isoformat()
+        else:
+            start = self.start
+
+        end: None | str | Unset
+        if isinstance(self.end, Unset):
+            end = UNSET
+        elif isinstance(self.end, datetime.datetime):
+            end = self.end.isoformat()
+        else:
+            end = self.end
+
+        present_date: None | str | Unset
+        if isinstance(self.present_date, Unset):
+            present_date = UNSET
+        elif isinstance(self.present_date, datetime.datetime):
+            present_date = self.present_date.isoformat()
+        else:
+            present_date = self.present_date
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if start is not UNSET:
+            field_dict["start"] = start
+        if end is not UNSET:
+            field_dict["end"] = end
+        if present_date is not UNSET:
+            field_dict["present_date"] = present_date
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_start(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                start_type_0 = isoparse(data)
+
+                return start_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        start = _parse_start(d.pop("start", UNSET))
+
+        def _parse_end(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                end_type_0 = isoparse(data)
+
+                return end_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        end = _parse_end(d.pop("end", UNSET))
+
+        def _parse_present_date(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                present_date_type_0 = isoparse(data)
+
+                return present_date_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        present_date = _parse_present_date(d.pop("present_date", UNSET))
+
+        date_cutoffs = cls(
+            start=start,
+            end=end,
+            present_date=present_date,
+        )
+
+        date_cutoffs.additional_properties = d
+        return date_cutoffs
+
+    @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_mode.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class DedupeMode(str, Enum):
+    AGENTIC = "agentic"
+    DIRECT = "direct"
+
+    def __str__(self) -> str:
+        return str(self.value)

everyrow/generated/models/dedupe_query_params.py

@@ -0,0 +1,174 @@
+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 ..models.dedupe_mode import DedupeMode
+from ..models.embedding_models import EmbeddingModels
+from ..models.llm_enum import LLMEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DedupeQueryParams")
+
+
+@_attrs_define
+class DedupeQueryParams:
+    """Service-specific parameters for the deduplication service.
+
+    Attributes:
+        equivalence_relation (str): Description of what makes items equivalent
+        llm (LLMEnum | Unset):
+        chunk_size (int | Unset): Maximum number of items to process in a single LLM call Default: 25.
+        mode (DedupeMode | Unset):
+        preview (bool | Unset): When true, process only the first few items Default: False.
+        embedding_model (EmbeddingModels | Unset):
+        validate_groups (bool | Unset): Validate equivalence classes and split incorrectly merged groups before
+            selecting representatives Default: False.
+        use_clustering (bool | Unset): When true, cluster items by embedding similarity and only compare neighboring
+            clusters. When false, use sequential chunking and compare all chunks (O(n²)) Default: True.
+        early_stop_threshold (int | None | Unset): Stop cross-chunk comparisons for a row after this many consecutive
+            comparisons with no matches. None disables early stopping.
+    """
+
+    equivalence_relation: str
+    llm: LLMEnum | Unset = UNSET
+    chunk_size: int | Unset = 25
+    mode: DedupeMode | Unset = UNSET
+    preview: bool | Unset = False
+    embedding_model: EmbeddingModels | Unset = UNSET
+    validate_groups: bool | Unset = False
+    use_clustering: bool | Unset = True
+    early_stop_threshold: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        equivalence_relation = self.equivalence_relation
+
+        llm: str | Unset = UNSET
+        if not isinstance(self.llm, Unset):
+            llm = self.llm.value
+
+        chunk_size = self.chunk_size
+
+        mode: str | Unset = UNSET
+        if not isinstance(self.mode, Unset):
+            mode = self.mode.value
+
+        preview = self.preview
+
+        embedding_model: str | Unset = UNSET
+        if not isinstance(self.embedding_model, Unset):
+            embedding_model = self.embedding_model.value
+
+        validate_groups = self.validate_groups
+
+        use_clustering = self.use_clustering
+
+        early_stop_threshold: int | None | Unset
+        if isinstance(self.early_stop_threshold, Unset):
+            early_stop_threshold = UNSET
+        else:
+            early_stop_threshold = self.early_stop_threshold
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "equivalence_relation": equivalence_relation,
+            }
+        )
+        if llm is not UNSET:
+            field_dict["llm"] = llm
+        if chunk_size is not UNSET:
+            field_dict["chunk_size"] = chunk_size
+        if mode is not UNSET:
+            field_dict["mode"] = mode
+        if preview is not UNSET:
+            field_dict["preview"] = preview
+        if embedding_model is not UNSET:
+            field_dict["embedding_model"] = embedding_model
+        if validate_groups is not UNSET:
+            field_dict["validate_groups"] = validate_groups
+        if use_clustering is not UNSET:
+            field_dict["use_clustering"] = use_clustering
+        if early_stop_threshold is not UNSET:
+            field_dict["early_stop_threshold"] = early_stop_threshold
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        equivalence_relation = d.pop("equivalence_relation")
+
+        _llm = d.pop("llm", UNSET)
+        llm: LLMEnum | Unset
+        if isinstance(_llm, Unset):
+            llm = UNSET
+        else:
+            llm = LLMEnum(_llm)
+
+        chunk_size = d.pop("chunk_size", UNSET)
+
+        _mode = d.pop("mode", UNSET)
+        mode: DedupeMode | Unset
+        if isinstance(_mode, Unset):
+            mode = UNSET
+        else:
+            mode = DedupeMode(_mode)
+
+        preview = d.pop("preview", UNSET)
+
+        _embedding_model = d.pop("embedding_model", UNSET)
+        embedding_model: EmbeddingModels | Unset
+        if isinstance(_embedding_model, Unset):
+            embedding_model = UNSET
+        else:
+            embedding_model = EmbeddingModels(_embedding_model)
+
+        validate_groups = d.pop("validate_groups", UNSET)
+
+        use_clustering = d.pop("use_clustering", UNSET)
+
+        def _parse_early_stop_threshold(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        early_stop_threshold = _parse_early_stop_threshold(d.pop("early_stop_threshold", UNSET))
+
+        dedupe_query_params = cls(
+            equivalence_relation=equivalence_relation,
+            llm=llm,
+            chunk_size=chunk_size,
+            mode=mode,
+            preview=preview,
+            embedding_model=embedding_model,
+            validate_groups=validate_groups,
+            use_clustering=use_clustering,
+            early_stop_threshold=early_stop_threshold,
+        )
+
+        dedupe_query_params.additional_properties = d
+        return dedupe_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/dedupe_request_params.py

@@ -0,0 +1,311 @@
+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 ..models.processing_mode import ProcessingMode
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.dedupe_query_params import DedupeQueryParams
+
+
+T = TypeVar("T", bound="DedupeRequestParams")
+
+
+@_attrs_define
+class DedupeRequestParams:
+    """Request parameters for the deduplication service.
+
+    Attributes:
+        query (DedupeQueryParams): Service-specific parameters for the deduplication service.
+        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['dedupe'] | Unset):  Default: 'dedupe'.
+        processing_mode (ProcessingMode | Unset):
+    """
+
+    query: DedupeQueryParams
+    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["dedupe"] | Unset = "dedupe"
+    processing_mode: ProcessingMode | Unset = UNSET
+    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: str | Unset = UNSET
+        if not isinstance(self.processing_mode, Unset):
+            processing_mode = self.processing_mode.value
+
+        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.dedupe_query_params import DedupeQueryParams
+
+        d = dict(src_dict)
+        query = DedupeQueryParams.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["dedupe"] | Unset, d.pop("task_type", UNSET))
+        if task_type != "dedupe" and not isinstance(task_type, Unset):
+            raise ValueError(f"task_type must match const 'dedupe', got '{task_type}'")
+
+        _processing_mode = d.pop("processing_mode", UNSET)
+        processing_mode: ProcessingMode | Unset
+        if isinstance(_processing_mode, Unset):
+            processing_mode = UNSET
+        else:
+            processing_mode = ProcessingMode(_processing_mode)
+
+        dedupe_request_params = 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,
+        )
+
+        dedupe_request_params.additional_properties = d
+        return dedupe_request_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