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

everyrow/generated/models/rank_operation.py

@@ -0,0 +1,203 @@
+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.rank_operation_input_type_1_item import RankOperationInputType1Item
+    from ..models.rank_operation_input_type_2 import RankOperationInputType2
+    from ..models.rank_operation_response_schema_type_0 import RankOperationResponseSchemaType0
+
+
+T = TypeVar("T", bound="RankOperation")
+
+
+@_attrs_define
+class RankOperation:
+    """
+    Attributes:
+        input_ (list[RankOperationInputType1Item] | RankOperationInputType2 | 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
+        task (str): Instructions for the AI to score each row
+        sort_by (str): Field name from response_schema to sort results by
+        session_id (None | Unset | UUID): Session ID. If not provided, a new session is auto-created for this task.
+        response_schema (None | RankOperationResponseSchemaType0 | Unset): JSON Schema for the response. Must include
+            the field specified in sort_by.
+        ascending (bool | Unset): Sort order: True for ascending, False for descending Default: True.
+    """
+
+    input_: list[RankOperationInputType1Item] | RankOperationInputType2 | UUID
+    task: str
+    sort_by: str
+    session_id: None | Unset | UUID = UNSET
+    response_schema: None | RankOperationResponseSchemaType0 | Unset = UNSET
+    ascending: bool | Unset = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.rank_operation_response_schema_type_0 import RankOperationResponseSchemaType0
+
+        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()
+
+        task = self.task
+
+        sort_by = self.sort_by
+
+        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
+
+        response_schema: dict[str, Any] | None | Unset
+        if isinstance(self.response_schema, Unset):
+            response_schema = UNSET
+        elif isinstance(self.response_schema, RankOperationResponseSchemaType0):
+            response_schema = self.response_schema.to_dict()
+        else:
+            response_schema = self.response_schema
+
+        ascending = self.ascending
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "input": input_,
+                "task": task,
+                "sort_by": sort_by,
+            }
+        )
+        if session_id is not UNSET:
+            field_dict["session_id"] = session_id
+        if response_schema is not UNSET:
+            field_dict["response_schema"] = response_schema
+        if ascending is not UNSET:
+            field_dict["ascending"] = ascending
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.rank_operation_input_type_1_item import RankOperationInputType1Item
+        from ..models.rank_operation_input_type_2 import RankOperationInputType2
+        from ..models.rank_operation_response_schema_type_0 import RankOperationResponseSchemaType0
+
+        d = dict(src_dict)
+
+        def _parse_input_(data: object) -> list[RankOperationInputType1Item] | RankOperationInputType2 | 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 = RankOperationInputType1Item.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 = RankOperationInputType2.from_dict(data)
+
+            return input_type_2
+
+        input_ = _parse_input_(d.pop("input"))
+
+        task = d.pop("task")
+
+        sort_by = d.pop("sort_by")
+
+        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))
+
+        def _parse_response_schema(data: object) -> None | RankOperationResponseSchemaType0 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                response_schema_type_0 = RankOperationResponseSchemaType0.from_dict(data)
+
+                return response_schema_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | RankOperationResponseSchemaType0 | Unset, data)
+
+        response_schema = _parse_response_schema(d.pop("response_schema", UNSET))
+
+        ascending = d.pop("ascending", UNSET)
+
+        rank_operation = cls(
+            input_=input_,
+            task=task,
+            sort_by=sort_by,
+            session_id=session_id,
+            response_schema=response_schema,
+            ascending=ascending,
+        )
+
+        rank_operation.additional_properties = d
+        return rank_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/rank_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="RankOperationInputType1Item")
+
+
+@_attrs_define
+class RankOperationInputType1Item:
+    """ """
+
+    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)
+        rank_operation_input_type_1_item = cls()
+
+        rank_operation_input_type_1_item.additional_properties = d
+        return rank_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/{export_request_token_data.py → rank_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="ExportRequestTokenData")
+T = TypeVar("T", bound="RankOperationInputType2")
 
 
 @_attrs_define
-class ExportRequestTokenData:
+class RankOperationInputType2:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -24,10 +24,10 @@ class ExportRequestTokenData:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        export_request_token_data = cls()
+        rank_operation_input_type_2 = cls()
 
-        export_request_token_data.additional_properties = d
-        return export_request_token_data
+        rank_operation_input_type_2.additional_properties = d
+        return rank_operation_input_type_2
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/{artifact_group_record_analysis_type_0.py → rank_operation_response_schema_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="ArtifactGroupRecordAnalysisType0")
+T = TypeVar("T", bound="RankOperationResponseSchemaType0")
 
 
 @_attrs_define
-class ArtifactGroupRecordAnalysisType0:
+class RankOperationResponseSchemaType0:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -24,10 +24,10 @@ class ArtifactGroupRecordAnalysisType0:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        artifact_group_record_analysis_type_0 = cls()
+        rank_operation_response_schema_type_0 = cls()
 
-        artifact_group_record_analysis_type_0.additional_properties = d
-        return artifact_group_record_analysis_type_0
+        rank_operation_response_schema_type_0.additional_properties = d
+        return rank_operation_response_schema_type_0
 
     @property
     def additional_keys(self) -> list[str]:

everyrow/generated/models/screen_operation.py

@@ -0,0 +1,186 @@
+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.screen_operation_input_type_1_item import ScreenOperationInputType1Item
+    from ..models.screen_operation_input_type_2 import ScreenOperationInputType2
+    from ..models.screen_operation_response_schema_type_0 import ScreenOperationResponseSchemaType0
+
+
+T = TypeVar("T", bound="ScreenOperation")
+
+
+@_attrs_define
+class ScreenOperation:
+    """
+    Attributes:
+        input_ (list[ScreenOperationInputType1Item] | ScreenOperationInputType2 | 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
+        task (str): Instructions for the AI to filter/screen each row
+        session_id (None | Unset | UUID): Session ID. If not provided, a new session is auto-created for this task.
+        response_schema (None | ScreenOperationResponseSchemaType0 | Unset): JSON Schema for the response format. If not
+            provided, uses default answer schema.
+    """
+
+    input_: list[ScreenOperationInputType1Item] | ScreenOperationInputType2 | UUID
+    task: str
+    session_id: None | Unset | UUID = UNSET
+    response_schema: None | ScreenOperationResponseSchemaType0 | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.screen_operation_response_schema_type_0 import ScreenOperationResponseSchemaType0
+
+        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()
+
+        task = self.task
+
+        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
+
+        response_schema: dict[str, Any] | None | Unset
+        if isinstance(self.response_schema, Unset):
+            response_schema = UNSET
+        elif isinstance(self.response_schema, ScreenOperationResponseSchemaType0):
+            response_schema = self.response_schema.to_dict()
+        else:
+            response_schema = self.response_schema
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "input": input_,
+                "task": task,
+            }
+        )
+        if session_id is not UNSET:
+            field_dict["session_id"] = session_id
+        if response_schema is not UNSET:
+            field_dict["response_schema"] = response_schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.screen_operation_input_type_1_item import ScreenOperationInputType1Item
+        from ..models.screen_operation_input_type_2 import ScreenOperationInputType2
+        from ..models.screen_operation_response_schema_type_0 import ScreenOperationResponseSchemaType0
+
+        d = dict(src_dict)
+
+        def _parse_input_(data: object) -> list[ScreenOperationInputType1Item] | ScreenOperationInputType2 | 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 = ScreenOperationInputType1Item.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 = ScreenOperationInputType2.from_dict(data)
+
+            return input_type_2
+
+        input_ = _parse_input_(d.pop("input"))
+
+        task = d.pop("task")
+
+        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))
+
+        def _parse_response_schema(data: object) -> None | ScreenOperationResponseSchemaType0 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                response_schema_type_0 = ScreenOperationResponseSchemaType0.from_dict(data)
+
+                return response_schema_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | ScreenOperationResponseSchemaType0 | Unset, data)
+
+        response_schema = _parse_response_schema(d.pop("response_schema", UNSET))
+
+        screen_operation = cls(
+            input_=input_,
+            task=task,
+            session_id=session_id,
+            response_schema=response_schema,
+        )
+
+        screen_operation.additional_properties = d
+        return screen_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/screen_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="ScreenOperationInputType1Item")
+
+
+@_attrs_define
+class ScreenOperationInputType1Item:
+    """ """
+
+    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)
+        screen_operation_input_type_1_item = cls()
+
+        screen_operation_input_type_1_item.additional_properties = d
+        return screen_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/screen_operation_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="ScreenOperationInputType2")
+
+
+@_attrs_define
+class ScreenOperationInputType2:
+    """ """
+
+    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)
+        screen_operation_input_type_2 = cls()
+
+        screen_operation_input_type_2.additional_properties = d
+        return screen_operation_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/screen_operation_response_schema_type_0.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="ScreenOperationResponseSchemaType0")
+
+
+@_attrs_define
+class ScreenOperationResponseSchemaType0:
+    """ """
+
+    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)
+        screen_operation_response_schema_type_0 = cls()
+
+        screen_operation_response_schema_type_0.additional_properties = d
+        return screen_operation_response_schema_type_0
+
+    @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/{create_session_response.py → session_response.py}

@@ -7,15 +7,14 @@ from uuid import UUID
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="CreateSessionResponse")
+T = TypeVar("T", bound="SessionResponse")
 
 
 @_attrs_define
-class CreateSessionResponse:
-    """Response containing the created session ID.
-
+class SessionResponse:
+    """
     Attributes:
-        session_id (UUID):
+        session_id (UUID): The ID of the created session
     """
 
     session_id: UUID
@@ -39,12 +38,12 @@ class CreateSessionResponse:
         d = dict(src_dict)
         session_id = UUID(d.pop("session_id"))
 
-        create_session_response = cls(
+        session_response = cls(
             session_id=session_id,
         )
 
-        create_session_response.additional_properties = d
-        return create_session_response
+        session_response.additional_properties = d
+        return session_response
 
     @property
     def additional_keys(self) -> list[str]: