everyrow 0.1.0__py3-none-any.whl

everyrow/generated/models/event_type.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class EventType(str, Enum):
+    ARTIFACTCHANGED = "artifact:changed"
+    ARTIFACT_PROGRESSCHANGED = "artifact_progress:changed"
+    CONVERSATIONCHANGED = "conversation:changed"
+    MESSAGECREATED = "message:created"
+    SESSIONCHANGED = "session:changed"
+    TASKCHANGED = "task:changed"
+    TRACECHANGED = "trace:changed"
+
+    def __str__(self) -> str:
+        return str(self.value)

everyrow/generated/models/execution_metadata.py

@@ -0,0 +1,146 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ExecutionMetadata")
+
+
+@_attrs_define
+class ExecutionMetadata:
+    """
+    Attributes:
+        subtasks (list[UUID]):
+        final_task (UUID):
+        final_task_on_error (UUID):
+        chord (UUID):
+        orchestrator_task (None | Unset | UUID):
+        orchestrator_controller_id (None | str | Unset):
+    """
+
+    subtasks: list[UUID]
+    final_task: UUID
+    final_task_on_error: UUID
+    chord: UUID
+    orchestrator_task: None | Unset | UUID = UNSET
+    orchestrator_controller_id: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        subtasks = []
+        for subtasks_item_data in self.subtasks:
+            subtasks_item = str(subtasks_item_data)
+            subtasks.append(subtasks_item)
+
+        final_task = str(self.final_task)
+
+        final_task_on_error = str(self.final_task_on_error)
+
+        chord = str(self.chord)
+
+        orchestrator_task: None | str | Unset
+        if isinstance(self.orchestrator_task, Unset):
+            orchestrator_task = UNSET
+        elif isinstance(self.orchestrator_task, UUID):
+            orchestrator_task = str(self.orchestrator_task)
+        else:
+            orchestrator_task = self.orchestrator_task
+
+        orchestrator_controller_id: None | str | Unset
+        if isinstance(self.orchestrator_controller_id, Unset):
+            orchestrator_controller_id = UNSET
+        else:
+            orchestrator_controller_id = self.orchestrator_controller_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "subtasks": subtasks,
+                "final_task": final_task,
+                "final_task_on_error": final_task_on_error,
+                "chord": chord,
+            }
+        )
+        if orchestrator_task is not UNSET:
+            field_dict["orchestrator_task"] = orchestrator_task
+        if orchestrator_controller_id is not UNSET:
+            field_dict["orchestrator_controller_id"] = orchestrator_controller_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        subtasks = []
+        _subtasks = d.pop("subtasks")
+        for subtasks_item_data in _subtasks:
+            subtasks_item = UUID(subtasks_item_data)
+
+            subtasks.append(subtasks_item)
+
+        final_task = UUID(d.pop("final_task"))
+
+        final_task_on_error = UUID(d.pop("final_task_on_error"))
+
+        chord = UUID(d.pop("chord"))
+
+        def _parse_orchestrator_task(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()
+                orchestrator_task_type_0 = UUID(data)
+
+                return orchestrator_task_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        orchestrator_task = _parse_orchestrator_task(d.pop("orchestrator_task", UNSET))
+
+        def _parse_orchestrator_controller_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        orchestrator_controller_id = _parse_orchestrator_controller_id(d.pop("orchestrator_controller_id", UNSET))
+
+        execution_metadata = cls(
+            subtasks=subtasks,
+            final_task=final_task,
+            final_task_on_error=final_task_on_error,
+            chord=chord,
+            orchestrator_task=orchestrator_task,
+            orchestrator_controller_id=orchestrator_controller_id,
+        )
+
+        execution_metadata.additional_properties = d
+        return execution_metadata
+
+    @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.py

@@ -0,0 +1,75 @@
+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.export_request_token_data import ExportRequestTokenData
+
+
+T = TypeVar("T", bound="ExportRequest")
+
+
+@_attrs_define
+class ExportRequest:
+    """
+    Attributes:
+        token_data (ExportRequestTokenData):
+        artifact_id (str):
+    """
+
+    token_data: ExportRequestTokenData
+    artifact_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        token_data = self.token_data.to_dict()
+
+        artifact_id = self.artifact_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "token_data": token_data,
+                "artifact_id": artifact_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.export_request_token_data import ExportRequestTokenData
+
+        d = dict(src_dict)
+        token_data = ExportRequestTokenData.from_dict(d.pop("token_data"))
+
+        artifact_id = d.pop("artifact_id")
+
+        export_request = cls(
+            token_data=token_data,
+            artifact_id=artifact_id,
+        )
+
+        export_request.additional_properties = d
+        return export_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/export_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="ExportRequestTokenData")
+
+
+@_attrs_define
+class ExportRequestTokenData:
+    """ """
+
+    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)
+        export_request_token_data = cls()
+
+        export_request_token_data.additional_properties = d
+        return export_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/export_to_google_sheets_export_post_response_export_to_google_sheets_export_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="ExportToGoogleSheetsExportPostResponseExportToGoogleSheetsExportPost")
+
+
+@_attrs_define
+class ExportToGoogleSheetsExportPostResponseExportToGoogleSheetsExportPost:
+    """ """
+
+    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)
+        export_to_google_sheets_export_post_response_export_to_google_sheets_export_post = cls()
+
+        export_to_google_sheets_export_post_response_export_to_google_sheets_export_post.additional_properties = d
+        return export_to_google_sheets_export_post_response_export_to_google_sheets_export_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/filter_query_params.py

@@ -0,0 +1,91 @@
+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.data_frame_method import DataFrameMethod
+
+T = TypeVar("T", bound="FilterQueryParams")
+
+
+@_attrs_define
+class FilterQueryParams:
+    """
+    Attributes:
+        field_name (str):
+        dataframe_method (DataFrameMethod):
+        rhs (bool | float | int | str):
+        invert_mask (bool):
+    """
+
+    field_name: str
+    dataframe_method: DataFrameMethod
+    rhs: bool | float | int | str
+    invert_mask: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_name = self.field_name
+
+        dataframe_method = self.dataframe_method.value
+
+        rhs: bool | float | int | str
+        rhs = self.rhs
+
+        invert_mask = self.invert_mask
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "field_name": field_name,
+                "dataframe_method": dataframe_method,
+                "rhs": rhs,
+                "invert_mask": invert_mask,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        field_name = d.pop("field_name")
+
+        dataframe_method = DataFrameMethod(d.pop("dataframe_method"))
+
+        def _parse_rhs(data: object) -> bool | float | int | str:
+            return cast(bool | float | int | str, data)
+
+        rhs = _parse_rhs(d.pop("rhs"))
+
+        invert_mask = d.pop("invert_mask")
+
+        filter_query_params = cls(
+            field_name=field_name,
+            dataframe_method=dataframe_method,
+            rhs=rhs,
+            invert_mask=invert_mask,
+        )
+
+        filter_query_params.additional_properties = d
+        return filter_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