everyrow 0.1.0__py3-none-any.whl

everyrow/generated/models/message_created_payload.py

@@ -0,0 +1,98 @@
+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="MessageCreatedPayload")
+
+
+@_attrs_define
+class MessageCreatedPayload:
+    """
+    Attributes:
+        conversation_ids (list[UUID]):
+        event_type (EventType | Unset):
+        hide_on_frontend (bool | Unset):  Default: False.
+    """
+
+    conversation_ids: list[UUID]
+    event_type: EventType | Unset = UNSET
+    hide_on_frontend: bool | Unset = False
+    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
+
+        hide_on_frontend = self.hide_on_frontend
+
+        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
+        if hide_on_frontend is not UNSET:
+            field_dict["hide_on_frontend"] = hide_on_frontend
+
+        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)
+
+        hide_on_frontend = d.pop("hide_on_frontend", UNSET)
+
+        message_created_payload = cls(
+            conversation_ids=conversation_ids,
+            event_type=event_type,
+            hide_on_frontend=hide_on_frontend,
+        )
+
+        message_created_payload.additional_properties = d
+        return message_created_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/multi_agent_effort_level.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MultiAgentEffortLevel(str, Enum):
+    HIGH = "high"
+    LOW = "low"
+    MEDIUM = "medium"
+
+    def __str__(self) -> str:
+        return str(self.value)

everyrow/generated/models/multi_agent_query_params.py

@@ -0,0 +1,264 @@
+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.llm_enum import LLMEnum
+from ..models.multi_agent_effort_level import MultiAgentEffortLevel
+from ..models.response_schema_type import ResponseSchemaType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MultiAgentQueryParams")
+
+
+@_attrs_define
+class MultiAgentQueryParams:
+    """
+    Attributes:
+        task (str): The task assigned to the multi-agent
+        llm (LLMEnum | Unset):
+        agenda (str | Unset): Research agenda, if any Default: ''.
+        selected_input_fields (list[str] | None | Unset): Fields to select from the input artifacts. If None, select all
+            fields.
+        apply_at_depth (int | Unset):  Default: -1.
+        preview (bool | Unset): When true, process only the first 5 inputs in map/map-expand operations Default: False.
+        is_expand (bool | Unset): When true, treat outputs as lists (expand behavior) Default: False.
+        flatten_map_expand (bool | Unset): When true with MAP mode and is_expand, flatten expanded results into single
+            group instead of nested groups Default: True.
+        response_schema (Any | Unset):  Default: {'_model_name': 'Root', 'answer': {'description': 'The response
+            answer', 'optional': False, 'type': 'str'}}.
+        response_schema_type (ResponseSchemaType | Unset): Type of response schema format.
+        effort_level (MultiAgentEffortLevel | Unset): Effort level for the multi-agent task.
+        agent_model (LLMEnum | Unset):
+        driver_model (LLMEnum | Unset):
+        agent_step_timeout_seconds (int | Unset): Agent step timeout in seconds (8-1400) Default: 300.
+        timeout_seconds (int | Unset): Full task timeout in seconds (20-360000) Default: 600.
+        retries (int | Unset): Number of retries (0-5) Default: 2.
+    """
+
+    task: str
+    llm: LLMEnum | Unset = UNSET
+    agenda: str | Unset = ""
+    selected_input_fields: list[str] | None | Unset = UNSET
+    apply_at_depth: int | Unset = -1
+    preview: bool | Unset = False
+    is_expand: bool | Unset = False
+    flatten_map_expand: bool | Unset = True
+    response_schema: Any | Unset = {
+        "_model_name": "Root",
+        "answer": {"description": "The response answer", "optional": False, "type": "str"},
+    }
+    response_schema_type: ResponseSchemaType | Unset = UNSET
+    effort_level: MultiAgentEffortLevel | Unset = UNSET
+    agent_model: LLMEnum | Unset = UNSET
+    driver_model: LLMEnum | Unset = UNSET
+    agent_step_timeout_seconds: int | Unset = 300
+    timeout_seconds: int | Unset = 600
+    retries: int | Unset = 2
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        task = self.task
+
+        llm: str | Unset = UNSET
+        if not isinstance(self.llm, Unset):
+            llm = self.llm.value
+
+        agenda = self.agenda
+
+        selected_input_fields: list[str] | None | Unset
+        if isinstance(self.selected_input_fields, Unset):
+            selected_input_fields = UNSET
+        elif isinstance(self.selected_input_fields, list):
+            selected_input_fields = self.selected_input_fields
+
+        else:
+            selected_input_fields = self.selected_input_fields
+
+        apply_at_depth = self.apply_at_depth
+
+        preview = self.preview
+
+        is_expand = self.is_expand
+
+        flatten_map_expand = self.flatten_map_expand
+
+        response_schema = self.response_schema
+
+        response_schema_type: str | Unset = UNSET
+        if not isinstance(self.response_schema_type, Unset):
+            response_schema_type = self.response_schema_type.value
+
+        effort_level: str | Unset = UNSET
+        if not isinstance(self.effort_level, Unset):
+            effort_level = self.effort_level.value
+
+        agent_model: str | Unset = UNSET
+        if not isinstance(self.agent_model, Unset):
+            agent_model = self.agent_model.value
+
+        driver_model: str | Unset = UNSET
+        if not isinstance(self.driver_model, Unset):
+            driver_model = self.driver_model.value
+
+        agent_step_timeout_seconds = self.agent_step_timeout_seconds
+
+        timeout_seconds = self.timeout_seconds
+
+        retries = self.retries
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "task": task,
+            }
+        )
+        if llm is not UNSET:
+            field_dict["llm"] = llm
+        if agenda is not UNSET:
+            field_dict["agenda"] = agenda
+        if selected_input_fields is not UNSET:
+            field_dict["selected_input_fields"] = selected_input_fields
+        if apply_at_depth is not UNSET:
+            field_dict["apply_at_depth"] = apply_at_depth
+        if preview is not UNSET:
+            field_dict["preview"] = preview
+        if is_expand is not UNSET:
+            field_dict["is_expand"] = is_expand
+        if flatten_map_expand is not UNSET:
+            field_dict["flatten_map_expand"] = flatten_map_expand
+        if response_schema is not UNSET:
+            field_dict["response_schema"] = response_schema
+        if response_schema_type is not UNSET:
+            field_dict["response_schema_type"] = response_schema_type
+        if effort_level is not UNSET:
+            field_dict["effort_level"] = effort_level
+        if agent_model is not UNSET:
+            field_dict["agent_model"] = agent_model
+        if driver_model is not UNSET:
+            field_dict["driver_model"] = driver_model
+        if agent_step_timeout_seconds is not UNSET:
+            field_dict["agent_step_timeout_seconds"] = agent_step_timeout_seconds
+        if timeout_seconds is not UNSET:
+            field_dict["timeout_seconds"] = timeout_seconds
+        if retries is not UNSET:
+            field_dict["retries"] = retries
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        task = d.pop("task")
+
+        _llm = d.pop("llm", UNSET)
+        llm: LLMEnum | Unset
+        if isinstance(_llm, Unset):
+            llm = UNSET
+        else:
+            llm = LLMEnum(_llm)
+
+        agenda = d.pop("agenda", UNSET)
+
+        def _parse_selected_input_fields(data: object) -> list[str] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                selected_input_fields_type_0 = cast(list[str], data)
+
+                return selected_input_fields_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[str] | None | Unset, data)
+
+        selected_input_fields = _parse_selected_input_fields(d.pop("selected_input_fields", UNSET))
+
+        apply_at_depth = d.pop("apply_at_depth", UNSET)
+
+        preview = d.pop("preview", UNSET)
+
+        is_expand = d.pop("is_expand", UNSET)
+
+        flatten_map_expand = d.pop("flatten_map_expand", UNSET)
+
+        response_schema = d.pop("response_schema", UNSET)
+
+        _response_schema_type = d.pop("response_schema_type", UNSET)
+        response_schema_type: ResponseSchemaType | Unset
+        if isinstance(_response_schema_type, Unset):
+            response_schema_type = UNSET
+        else:
+            response_schema_type = ResponseSchemaType(_response_schema_type)
+
+        _effort_level = d.pop("effort_level", UNSET)
+        effort_level: MultiAgentEffortLevel | Unset
+        if isinstance(_effort_level, Unset):
+            effort_level = UNSET
+        else:
+            effort_level = MultiAgentEffortLevel(_effort_level)
+
+        _agent_model = d.pop("agent_model", UNSET)
+        agent_model: LLMEnum | Unset
+        if isinstance(_agent_model, Unset):
+            agent_model = UNSET
+        else:
+            agent_model = LLMEnum(_agent_model)
+
+        _driver_model = d.pop("driver_model", UNSET)
+        driver_model: LLMEnum | Unset
+        if isinstance(_driver_model, Unset):
+            driver_model = UNSET
+        else:
+            driver_model = LLMEnum(_driver_model)
+
+        agent_step_timeout_seconds = d.pop("agent_step_timeout_seconds", UNSET)
+
+        timeout_seconds = d.pop("timeout_seconds", UNSET)
+
+        retries = d.pop("retries", UNSET)
+
+        multi_agent_query_params = cls(
+            task=task,
+            llm=llm,
+            agenda=agenda,
+            selected_input_fields=selected_input_fields,
+            apply_at_depth=apply_at_depth,
+            preview=preview,
+            is_expand=is_expand,
+            flatten_map_expand=flatten_map_expand,
+            response_schema=response_schema,
+            response_schema_type=response_schema_type,
+            effort_level=effort_level,
+            agent_model=agent_model,
+            driver_model=driver_model,
+            agent_step_timeout_seconds=agent_step_timeout_seconds,
+            timeout_seconds=timeout_seconds,
+            retries=retries,
+        )
+
+        multi_agent_query_params.additional_properties = d
+        return multi_agent_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/multi_modal_chat_message.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.multi_modal_chat_message_role import MultiModalChatMessageRole
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.image_chat_content_part import ImageChatContentPart
+    from ..models.text_chat_content_part import TextChatContentPart
+
+
+T = TypeVar("T", bound="MultiModalChatMessage")
+
+
+@_attrs_define
+class MultiModalChatMessage:
+    """
+    Attributes:
+        role (MultiModalChatMessageRole):
+        content (list[ImageChatContentPart | TextChatContentPart]):
+        message_type (Literal['multi_modal'] | Unset):  Default: 'multi_modal'.
+        completion_tokens (int | None | Unset):
+        cacheable (bool | Unset):  Default: False.
+        explicit_cache_breakpoint (bool | Unset):  Default: False.
+    """
+
+    role: MultiModalChatMessageRole
+    content: list[ImageChatContentPart | TextChatContentPart]
+    message_type: Literal["multi_modal"] | Unset = "multi_modal"
+    completion_tokens: int | None | Unset = UNSET
+    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]:
+        from ..models.text_chat_content_part import TextChatContentPart
+
+        role = self.role.value
+
+        content = []
+        for content_item_data in self.content:
+            content_item: dict[str, Any]
+            if isinstance(content_item_data, TextChatContentPart):
+                content_item = content_item_data.to_dict()
+            else:
+                content_item = content_item_data.to_dict()
+
+            content.append(content_item)
+
+        message_type = self.message_type
+
+        completion_tokens: int | None | Unset
+        if isinstance(self.completion_tokens, Unset):
+            completion_tokens = UNSET
+        else:
+            completion_tokens = self.completion_tokens
+
+        cacheable = self.cacheable
+
+        explicit_cache_breakpoint = self.explicit_cache_breakpoint
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+                "content": content,
+            }
+        )
+        if message_type is not UNSET:
+            field_dict["message_type"] = message_type
+        if completion_tokens is not UNSET:
+            field_dict["completion_tokens"] = completion_tokens
+        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:
+        from ..models.image_chat_content_part import ImageChatContentPart
+        from ..models.text_chat_content_part import TextChatContentPart
+
+        d = dict(src_dict)
+        role = MultiModalChatMessageRole(d.pop("role"))
+
+        content = []
+        _content = d.pop("content")
+        for content_item_data in _content:
+
+            def _parse_content_item(data: object) -> ImageChatContentPart | TextChatContentPart:
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    content_item_type_0 = TextChatContentPart.from_dict(data)
+
+                    return content_item_type_0
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                if not isinstance(data, dict):
+                    raise TypeError()
+                content_item_type_1 = ImageChatContentPart.from_dict(data)
+
+                return content_item_type_1
+
+            content_item = _parse_content_item(content_item_data)
+
+            content.append(content_item)
+
+        message_type = cast(Literal["multi_modal"] | Unset, d.pop("message_type", UNSET))
+        if message_type != "multi_modal" and not isinstance(message_type, Unset):
+            raise ValueError(f"message_type must match const 'multi_modal', got '{message_type}'")
+
+        def _parse_completion_tokens(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        completion_tokens = _parse_completion_tokens(d.pop("completion_tokens", UNSET))
+
+        cacheable = d.pop("cacheable", UNSET)
+
+        explicit_cache_breakpoint = d.pop("explicit_cache_breakpoint", UNSET)
+
+        multi_modal_chat_message = cls(
+            role=role,
+            content=content,
+            message_type=message_type,
+            completion_tokens=completion_tokens,
+            cacheable=cacheable,
+            explicit_cache_breakpoint=explicit_cache_breakpoint,
+        )
+
+        multi_modal_chat_message.additional_properties = d
+        return multi_modal_chat_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/multi_modal_chat_message_role.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MultiModalChatMessageRole(str, Enum):
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    USER = "user"
+
+    def __str__(self) -> str:
+        return str(self.value)

everyrow/generated/models/preview_metadata.py

@@ -0,0 +1,144 @@
+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="PreviewMetadata")
+
+
+@_attrs_define
+class PreviewMetadata:
+    """
+    Attributes:
+        original_task_id (UUID):
+        index (int | None | Unset):
+        label (None | str | Unset):
+        description (None | str | Unset):
+        num_omitted_artifacts (int | None | Unset):
+    """
+
+    original_task_id: UUID
+    index: int | None | Unset = UNSET
+    label: None | str | Unset = UNSET
+    description: None | str | Unset = UNSET
+    num_omitted_artifacts: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        original_task_id = str(self.original_task_id)
+
+        index: int | None | Unset
+        if isinstance(self.index, Unset):
+            index = UNSET
+        else:
+            index = self.index
+
+        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
+
+        num_omitted_artifacts: int | None | Unset
+        if isinstance(self.num_omitted_artifacts, Unset):
+            num_omitted_artifacts = UNSET
+        else:
+            num_omitted_artifacts = self.num_omitted_artifacts
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "original_task_id": original_task_id,
+            }
+        )
+        if index is not UNSET:
+            field_dict["index"] = index
+        if label is not UNSET:
+            field_dict["label"] = label
+        if description is not UNSET:
+            field_dict["description"] = description
+        if num_omitted_artifacts is not UNSET:
+            field_dict["num_omitted_artifacts"] = num_omitted_artifacts
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        original_task_id = UUID(d.pop("original_task_id"))
+
+        def _parse_index(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        index = _parse_index(d.pop("index", 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_num_omitted_artifacts(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        num_omitted_artifacts = _parse_num_omitted_artifacts(d.pop("num_omitted_artifacts", UNSET))
+
+        preview_metadata = cls(
+            original_task_id=original_task_id,
+            index=index,
+            label=label,
+            description=description,
+            num_omitted_artifacts=num_omitted_artifacts,
+        )
+
+        preview_metadata.additional_properties = d
+        return preview_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/processing_mode.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ProcessingMode(str, Enum):
+    MAP = "map"
+    REDUCE = "reduce"
+    TRANSFORM = "transform"
+
+    def __str__(self) -> str:
+        return str(self.value)