everyrow 0.1.0__py3-none-any.whl

everyrow/generated/models/continue_task_request.py

@@ -0,0 +1,133 @@
+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.continue_reason import ContinueReason
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ContinueTaskRequest")
+
+
+@_attrs_define
+class ContinueTaskRequest:
+    """
+    Attributes:
+        task_id (UUID):
+        reason (ContinueReason):
+        conversation_id (None | Unset | UUID):
+        session_id (None | Unset | UUID):
+    """
+
+    task_id: UUID
+    reason: ContinueReason
+    conversation_id: None | Unset | UUID = UNSET
+    session_id: None | Unset | UUID = 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)
+
+        reason = self.reason.value
+
+        conversation_id: None | str | Unset
+        if isinstance(self.conversation_id, Unset):
+            conversation_id = UNSET
+        elif isinstance(self.conversation_id, UUID):
+            conversation_id = str(self.conversation_id)
+        else:
+            conversation_id = self.conversation_id
+
+        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(
+            {
+                "task_id": task_id,
+                "reason": reason,
+            }
+        )
+        if conversation_id is not UNSET:
+            field_dict["conversation_id"] = conversation_id
+        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:
+        d = dict(src_dict)
+        task_id = UUID(d.pop("task_id"))
+
+        reason = ContinueReason(d.pop("reason"))
+
+        def _parse_conversation_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()
+                conversation_id_type_0 = UUID(data)
+
+                return conversation_id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        conversation_id = _parse_conversation_id(d.pop("conversation_id", 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))
+
+        continue_task_request = cls(
+            task_id=task_id,
+            reason=reason,
+            conversation_id=conversation_id,
+            session_id=session_id,
+        )
+
+        continue_task_request.additional_properties = d
+        return continue_task_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/controller_improvement_round.py

@@ -0,0 +1,79 @@
+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
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.agent_improvement_instruction import AgentImprovementInstruction
+
+
+T = TypeVar("T", bound="ControllerImprovementRound")
+
+
+@_attrs_define
+class ControllerImprovementRound:
+    """
+    Attributes:
+        instructions (list[AgentImprovementInstruction] | Unset): Per-agent improvement instructions
+    """
+
+    instructions: list[AgentImprovementInstruction] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        instructions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.instructions, Unset):
+            instructions = []
+            for instructions_item_data in self.instructions:
+                instructions_item = instructions_item_data.to_dict()
+                instructions.append(instructions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if instructions is not UNSET:
+            field_dict["instructions"] = instructions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.agent_improvement_instruction import AgentImprovementInstruction
+
+        d = dict(src_dict)
+        _instructions = d.pop("instructions", UNSET)
+        instructions: list[AgentImprovementInstruction] | Unset = UNSET
+        if _instructions is not UNSET:
+            instructions = []
+            for instructions_item_data in _instructions:
+                instructions_item = AgentImprovementInstruction.from_dict(instructions_item_data)
+
+                instructions.append(instructions_item)
+
+        controller_improvement_round = cls(
+            instructions=instructions,
+        )
+
+        controller_improvement_round.additional_properties = d
+        return controller_improvement_round
+
+    @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/conversation_changed_payload.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.event_type import EventType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ConversationChangedPayload")
+
+
+@_attrs_define
+class ConversationChangedPayload:
+    """
+    Attributes:
+        conversation_ids (list[UUID]):
+        event_type (EventType | Unset):
+    """
+
+    conversation_ids: list[UUID]
+    event_type: EventType | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        conversation_ids = []
+        for conversation_ids_item_data in self.conversation_ids:
+            conversation_ids_item = str(conversation_ids_item_data)
+            conversation_ids.append(conversation_ids_item)
+
+        event_type: str | Unset = UNSET
+        if not isinstance(self.event_type, Unset):
+            event_type = self.event_type.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "conversation_ids": conversation_ids,
+            }
+        )
+        if event_type is not UNSET:
+            field_dict["event_type"] = event_type
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        conversation_ids = []
+        _conversation_ids = d.pop("conversation_ids")
+        for conversation_ids_item_data in _conversation_ids:
+            conversation_ids_item = UUID(conversation_ids_item_data)
+
+            conversation_ids.append(conversation_ids_item)
+
+        _event_type = d.pop("event_type", UNSET)
+        event_type: EventType | Unset
+        if isinstance(_event_type, Unset):
+            event_type = UNSET
+        else:
+            event_type = EventType(_event_type)
+
+        conversation_changed_payload = cls(
+            conversation_ids=conversation_ids,
+            event_type=event_type,
+        )
+
+        conversation_changed_payload.additional_properties = d
+        return conversation_changed_payload
+
+    @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/copy_artifacts_request.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CopyArtifactsRequest")
+
+
+@_attrs_define
+class CopyArtifactsRequest:
+    """
+    Attributes:
+        source_artifact_id (UUID):
+        target_session_id (UUID):
+    """
+
+    source_artifact_id: UUID
+    target_session_id: UUID
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        source_artifact_id = str(self.source_artifact_id)
+
+        target_session_id = str(self.target_session_id)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "source_artifact_id": source_artifact_id,
+                "target_session_id": target_session_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        source_artifact_id = UUID(d.pop("source_artifact_id"))
+
+        target_session_id = UUID(d.pop("target_session_id"))
+
+        copy_artifacts_request = cls(
+            source_artifact_id=source_artifact_id,
+            target_session_id=target_session_id,
+        )
+
+        copy_artifacts_request.additional_properties = d
+        return copy_artifacts_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/copy_artifacts_response.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CopyArtifactsResponse")
+
+
+@_attrs_define
+class CopyArtifactsResponse:
+    """
+    Attributes:
+        artifact_id (UUID):
+        task_id (UUID):
+    """
+
+    artifact_id: UUID
+    task_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)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "artifact_id": artifact_id,
+                "task_id": task_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        artifact_id = UUID(d.pop("artifact_id"))
+
+        task_id = UUID(d.pop("task_id"))
+
+        copy_artifacts_response = cls(
+            artifact_id=artifact_id,
+            task_id=task_id,
+        )
+
+        copy_artifacts_response.additional_properties = d
+        return copy_artifacts_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/copy_workflow_request.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CopyWorkflowRequest")
+
+
+@_attrs_define
+class CopyWorkflowRequest:
+    """
+    Attributes:
+        workflow_id (UUID):
+    """
+
+    workflow_id: UUID
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        workflow_id = str(self.workflow_id)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "workflow_id": workflow_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        workflow_id = UUID(d.pop("workflow_id"))
+
+        copy_workflow_request = cls(
+            workflow_id=workflow_id,
+        )
+
+        copy_workflow_request.additional_properties = d
+        return copy_workflow_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/copy_workflow_response.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CopyWorkflowResponse")
+
+
+@_attrs_define
+class CopyWorkflowResponse:
+    """
+    Attributes:
+        workflow_id (UUID):
+        message (str):
+    """
+
+    workflow_id: UUID
+    message: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        workflow_id = str(self.workflow_id)
+
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "workflow_id": workflow_id,
+                "message": message,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        workflow_id = UUID(d.pop("workflow_id"))
+
+        message = d.pop("message")
+
+        copy_workflow_response = cls(
+            workflow_id=workflow_id,
+            message=message,
+        )
+
+        copy_workflow_response.additional_properties = d
+        return copy_workflow_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/create_api_key_request.py

@@ -0,0 +1,95 @@
+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="CreateAPIKeyRequest")
+
+
+@_attrs_define
+class CreateAPIKeyRequest:
+    """
+    Attributes:
+        name (str):
+        expires_at (datetime.datetime | None | Unset):
+    """
+
+    name: str
+    expires_at: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        expires_at: None | str | Unset
+        if isinstance(self.expires_at, Unset):
+            expires_at = UNSET
+        elif isinstance(self.expires_at, datetime.datetime):
+            expires_at = self.expires_at.isoformat()
+        else:
+            expires_at = self.expires_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if expires_at is not UNSET:
+            field_dict["expires_at"] = expires_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        def _parse_expires_at(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()
+                expires_at_type_0 = isoparse(data)
+
+                return expires_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        expires_at = _parse_expires_at(d.pop("expires_at", UNSET))
+
+        create_api_key_request = cls(
+            name=name,
+            expires_at=expires_at,
+        )
+
+        create_api_key_request.additional_properties = d
+        return create_api_key_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