everyrow 0.1.0__py3-none-any.whl

everyrow/generated/models/text_chat_content_part.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TextChatContentPart")
+
+
+@_attrs_define
+class TextChatContentPart:
+    """
+    Attributes:
+        text (str):
+        type_ (Literal['text'] | Unset):  Default: 'text'.
+    """
+
+    text: str
+    type_: Literal["text"] | Unset = "text"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        text = self.text
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "text": text,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        text = d.pop("text")
+
+        type_ = cast(Literal["text"] | Unset, d.pop("type", UNSET))
+        if type_ != "text" and not isinstance(type_, Unset):
+            raise ValueError(f"type must match const 'text', got '{type_}'")
+
+        text_chat_content_part = cls(
+            text=text,
+            type_=type_,
+        )
+
+        text_chat_content_part.additional_properties = d
+        return text_chat_content_part
+
+    @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/tool_response_message.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ToolResponseMessage")
+
+
+@_attrs_define
+class ToolResponseMessage:
+    """
+    Attributes:
+        tool_call_id (str):
+        content (str):
+        description (str):
+        tool_name (str):
+        message_type (Literal['tool_response'] | Unset):  Default: 'tool_response'.
+        role (Literal['tool'] | Unset):  Default: 'tool'.
+        cacheable (bool | Unset):  Default: False.
+        explicit_cache_breakpoint (bool | Unset):  Default: False.
+    """
+
+    tool_call_id: str
+    content: str
+    description: str
+    tool_name: str
+    message_type: Literal["tool_response"] | Unset = "tool_response"
+    role: Literal["tool"] | Unset = "tool"
+    cacheable: bool | Unset = False
+    explicit_cache_breakpoint: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tool_call_id = self.tool_call_id
+
+        content = self.content
+
+        description = self.description
+
+        tool_name = self.tool_name
+
+        message_type = self.message_type
+
+        role = self.role
+
+        cacheable = self.cacheable
+
+        explicit_cache_breakpoint = self.explicit_cache_breakpoint
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tool_call_id": tool_call_id,
+                "content": content,
+                "description": description,
+                "tool_name": tool_name,
+            }
+        )
+        if message_type is not UNSET:
+            field_dict["message_type"] = message_type
+        if role is not UNSET:
+            field_dict["role"] = role
+        if cacheable is not UNSET:
+            field_dict["cacheable"] = cacheable
+        if explicit_cache_breakpoint is not UNSET:
+            field_dict["explicit_cache_breakpoint"] = explicit_cache_breakpoint
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        tool_call_id = d.pop("tool_call_id")
+
+        content = d.pop("content")
+
+        description = d.pop("description")
+
+        tool_name = d.pop("tool_name")
+
+        message_type = cast(Literal["tool_response"] | Unset, d.pop("message_type", UNSET))
+        if message_type != "tool_response" and not isinstance(message_type, Unset):
+            raise ValueError(f"message_type must match const 'tool_response', got '{message_type}'")
+
+        role = cast(Literal["tool"] | Unset, d.pop("role", UNSET))
+        if role != "tool" and not isinstance(role, Unset):
+            raise ValueError(f"role must match const 'tool', got '{role}'")
+
+        cacheable = d.pop("cacheable", UNSET)
+
+        explicit_cache_breakpoint = d.pop("explicit_cache_breakpoint", UNSET)
+
+        tool_response_message = cls(
+            tool_call_id=tool_call_id,
+            content=content,
+            description=description,
+            tool_name=tool_name,
+            message_type=message_type,
+            role=role,
+            cacheable=cacheable,
+            explicit_cache_breakpoint=explicit_cache_breakpoint,
+        )
+
+        tool_response_message.additional_properties = d
+        return tool_response_message
+
+    @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/toolkit_constants.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ToolkitConstants")
+
+
+@_attrs_define
+class ToolkitConstants:
+    """
+    Attributes:
+        low_effort_agent_iteration_budget (Literal[5] | Unset):  Default: 5.
+        high_effort_agent_iteration_budget (Literal[10] | Unset):  Default: 10.
+    """
+
+    low_effort_agent_iteration_budget: Literal[5] | Unset = 5
+    high_effort_agent_iteration_budget: Literal[10] | Unset = 10
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        low_effort_agent_iteration_budget = self.low_effort_agent_iteration_budget
+
+        high_effort_agent_iteration_budget = self.high_effort_agent_iteration_budget
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if low_effort_agent_iteration_budget is not UNSET:
+            field_dict["low_effort_agent_iteration_budget"] = low_effort_agent_iteration_budget
+        if high_effort_agent_iteration_budget is not UNSET:
+            field_dict["high_effort_agent_iteration_budget"] = high_effort_agent_iteration_budget
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        low_effort_agent_iteration_budget = cast(Literal[5] | Unset, d.pop("low_effort_agent_iteration_budget", UNSET))
+        if low_effort_agent_iteration_budget != 5 and not isinstance(low_effort_agent_iteration_budget, Unset):
+            raise ValueError(
+                f"low_effort_agent_iteration_budget must match const 5, got '{low_effort_agent_iteration_budget}'"
+            )
+
+        high_effort_agent_iteration_budget = cast(
+            Literal[10] | Unset, d.pop("high_effort_agent_iteration_budget", UNSET)
+        )
+        if high_effort_agent_iteration_budget != 10 and not isinstance(high_effort_agent_iteration_budget, Unset):
+            raise ValueError(
+                f"high_effort_agent_iteration_budget must match const 10, got '{high_effort_agent_iteration_budget}'"
+            )
+
+        toolkit_constants = cls(
+            low_effort_agent_iteration_budget=low_effort_agent_iteration_budget,
+            high_effort_agent_iteration_budget=high_effort_agent_iteration_budget,
+        )
+
+        toolkit_constants.additional_properties = d
+        return toolkit_constants
+
+    @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/trace_changed_payload.py

@@ -0,0 +1,94 @@
+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 ..models.event_type import EventType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.trace_info import TraceInfo
+
+
+T = TypeVar("T", bound="TraceChangedPayload")
+
+
+@_attrs_define
+class TraceChangedPayload:
+    """
+    Attributes:
+        traces (list[TraceInfo]):
+        event_type (EventType | Unset):
+    """
+
+    traces: list[TraceInfo]
+    event_type: EventType | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        traces = []
+        for traces_item_data in self.traces:
+            traces_item = traces_item_data.to_dict()
+            traces.append(traces_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(
+            {
+                "traces": traces,
+            }
+        )
+        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:
+        from ..models.trace_info import TraceInfo
+
+        d = dict(src_dict)
+        traces = []
+        _traces = d.pop("traces")
+        for traces_item_data in _traces:
+            traces_item = TraceInfo.from_dict(traces_item_data)
+
+            traces.append(traces_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)
+
+        trace_changed_payload = cls(
+            traces=traces,
+            event_type=event_type,
+        )
+
+        trace_changed_payload.additional_properties = d
+        return trace_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/trace_info.py

@@ -0,0 +1,78 @@
+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="TraceInfo")
+
+
+@_attrs_define
+class TraceInfo:
+    """
+    Attributes:
+        task_id (UUID):
+        trace_id (UUID):
+        artifact_id (UUID):
+    """
+
+    task_id: UUID
+    trace_id: UUID
+    artifact_id: UUID
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        task_id = str(self.task_id)
+
+        trace_id = str(self.trace_id)
+
+        artifact_id = str(self.artifact_id)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "task_id": task_id,
+                "trace_id": trace_id,
+                "artifact_id": artifact_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"))
+
+        trace_id = UUID(d.pop("trace_id"))
+
+        artifact_id = UUID(d.pop("artifact_id"))
+
+        trace_info = cls(
+            task_id=task_id,
+            trace_id=trace_id,
+            artifact_id=artifact_id,
+        )
+
+        trace_info.additional_properties = d
+        return trace_info
+
+    @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/trigger_workflow_execution_request.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+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.trigger_workflow_execution_request_task_params import TriggerWorkflowExecutionRequestTaskParams
+    from ..models.workflow_leaf_node_input import WorkflowLeafNodeInput
+
+
+T = TypeVar("T", bound="TriggerWorkflowExecutionRequest")
+
+
+@_attrs_define
+class TriggerWorkflowExecutionRequest:
+    """
+    Attributes:
+        workflow_id (UUID):
+        inputs (list[WorkflowLeafNodeInput]):
+        session_id (UUID):
+        task_params (TriggerWorkflowExecutionRequestTaskParams | Unset):
+    """
+
+    workflow_id: UUID
+    inputs: list[WorkflowLeafNodeInput]
+    session_id: UUID
+    task_params: TriggerWorkflowExecutionRequestTaskParams | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        workflow_id = str(self.workflow_id)
+
+        inputs = []
+        for inputs_item_data in self.inputs:
+            inputs_item = inputs_item_data.to_dict()
+            inputs.append(inputs_item)
+
+        session_id = str(self.session_id)
+
+        task_params: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.task_params, Unset):
+            task_params = self.task_params.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "workflow_id": workflow_id,
+                "inputs": inputs,
+                "session_id": session_id,
+            }
+        )
+        if task_params is not UNSET:
+            field_dict["task_params"] = task_params
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.trigger_workflow_execution_request_task_params import TriggerWorkflowExecutionRequestTaskParams
+        from ..models.workflow_leaf_node_input import WorkflowLeafNodeInput
+
+        d = dict(src_dict)
+        workflow_id = UUID(d.pop("workflow_id"))
+
+        inputs = []
+        _inputs = d.pop("inputs")
+        for inputs_item_data in _inputs:
+            inputs_item = WorkflowLeafNodeInput.from_dict(inputs_item_data)
+
+            inputs.append(inputs_item)
+
+        session_id = UUID(d.pop("session_id"))
+
+        _task_params = d.pop("task_params", UNSET)
+        task_params: TriggerWorkflowExecutionRequestTaskParams | Unset
+        if isinstance(_task_params, Unset):
+            task_params = UNSET
+        else:
+            task_params = TriggerWorkflowExecutionRequestTaskParams.from_dict(_task_params)
+
+        trigger_workflow_execution_request = cls(
+            workflow_id=workflow_id,
+            inputs=inputs,
+            session_id=session_id,
+            task_params=task_params,
+        )
+
+        trigger_workflow_execution_request.additional_properties = d
+        return trigger_workflow_execution_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/trigger_workflow_execution_request_task_params.py

@@ -0,0 +1,65 @@
+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.trigger_workflow_execution_request_task_params_additional_property import (
+        TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty,
+    )
+
+
+T = TypeVar("T", bound="TriggerWorkflowExecutionRequestTaskParams")
+
+
+@_attrs_define
+class TriggerWorkflowExecutionRequestTaskParams:
+    """ """
+
+    additional_properties: dict[str, TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.trigger_workflow_execution_request_task_params_additional_property import (
+            TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty,
+        )
+
+        d = dict(src_dict)
+        trigger_workflow_execution_request_task_params = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        trigger_workflow_execution_request_task_params.additional_properties = additional_properties
+        return trigger_workflow_execution_request_task_params
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty) -> 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/trigger_workflow_execution_request_task_params_additional_property.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="TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty")
+
+
+@_attrs_define
+class TriggerWorkflowExecutionRequestTaskParamsAdditionalProperty:
+    """ """
+
+    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)
+        trigger_workflow_execution_request_task_params_additional_property = cls()
+
+        trigger_workflow_execution_request_task_params_additional_property.additional_properties = d
+        return trigger_workflow_execution_request_task_params_additional_property
+
+    @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