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

everyrow/generated/models/map_multi_agent_request_params.py

@@ -1,313 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, Literal, 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.multi_agent_query_params import MultiAgentQueryParams
-
-
-T = TypeVar("T", bound="MapMultiAgentRequestParams")
-
-
-@_attrs_define
-class MapMultiAgentRequestParams:
-    """
-    Attributes:
-        query (MultiAgentQueryParams):
-        input_artifacts (list[UUID] | None | Unset):
-        context_artifacts (list[UUID] | None | Unset):
-        label (None | str | Unset): Short task label for use in the UI
-        description (None | str | Unset): Task description for use in the UI
-        task_id (None | Unset | UUID):
-        replaces_task_id (None | Unset | UUID): The ID of the task that this task replaces. Used e.g. by the full
-            version of a task that replaces a preview version.
-        twin_artifact_id (None | Unset | UUID): The ID of a reference artifact, e.g. the right table in Deep Merge
-            operation.
-        task_type (Literal['multiagent'] | Unset):  Default: 'multiagent'.
-        processing_mode (Literal['map'] | Unset):  Default: 'map'.
-        join_with_input (bool | Unset):  Default: False.
-    """
-
-    query: MultiAgentQueryParams
-    input_artifacts: list[UUID] | None | Unset = UNSET
-    context_artifacts: list[UUID] | None | Unset = UNSET
-    label: None | str | Unset = UNSET
-    description: None | str | Unset = UNSET
-    task_id: None | Unset | UUID = UNSET
-    replaces_task_id: None | Unset | UUID = UNSET
-    twin_artifact_id: None | Unset | UUID = UNSET
-    task_type: Literal["multiagent"] | Unset = "multiagent"
-    processing_mode: Literal["map"] | Unset = "map"
-    join_with_input: bool | Unset = False
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        query = self.query.to_dict()
-
-        input_artifacts: list[str] | None | Unset
-        if isinstance(self.input_artifacts, Unset):
-            input_artifacts = UNSET
-        elif isinstance(self.input_artifacts, list):
-            input_artifacts = []
-            for componentsschemas_input_artifacts_ids_item_data in self.input_artifacts:
-                componentsschemas_input_artifacts_ids_item = str(componentsschemas_input_artifacts_ids_item_data)
-                input_artifacts.append(componentsschemas_input_artifacts_ids_item)
-
-        else:
-            input_artifacts = self.input_artifacts
-
-        context_artifacts: list[str] | None | Unset
-        if isinstance(self.context_artifacts, Unset):
-            context_artifacts = UNSET
-        elif isinstance(self.context_artifacts, list):
-            context_artifacts = []
-            for componentsschemas_context_artifacts_ids_item_data in self.context_artifacts:
-                componentsschemas_context_artifacts_ids_item = str(componentsschemas_context_artifacts_ids_item_data)
-                context_artifacts.append(componentsschemas_context_artifacts_ids_item)
-
-        else:
-            context_artifacts = self.context_artifacts
-
-        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
-
-        task_id: None | str | Unset
-        if isinstance(self.task_id, Unset):
-            task_id = UNSET
-        elif isinstance(self.task_id, UUID):
-            task_id = str(self.task_id)
-        else:
-            task_id = self.task_id
-
-        replaces_task_id: None | str | Unset
-        if isinstance(self.replaces_task_id, Unset):
-            replaces_task_id = UNSET
-        elif isinstance(self.replaces_task_id, UUID):
-            replaces_task_id = str(self.replaces_task_id)
-        else:
-            replaces_task_id = self.replaces_task_id
-
-        twin_artifact_id: None | str | Unset
-        if isinstance(self.twin_artifact_id, Unset):
-            twin_artifact_id = UNSET
-        elif isinstance(self.twin_artifact_id, UUID):
-            twin_artifact_id = str(self.twin_artifact_id)
-        else:
-            twin_artifact_id = self.twin_artifact_id
-
-        task_type = self.task_type
-
-        processing_mode = self.processing_mode
-
-        join_with_input = self.join_with_input
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "query": query,
-            }
-        )
-        if input_artifacts is not UNSET:
-            field_dict["input_artifacts"] = input_artifacts
-        if context_artifacts is not UNSET:
-            field_dict["context_artifacts"] = context_artifacts
-        if label is not UNSET:
-            field_dict["label"] = label
-        if description is not UNSET:
-            field_dict["description"] = description
-        if task_id is not UNSET:
-            field_dict["task_id"] = task_id
-        if replaces_task_id is not UNSET:
-            field_dict["replaces_task_id"] = replaces_task_id
-        if twin_artifact_id is not UNSET:
-            field_dict["twin_artifact_id"] = twin_artifact_id
-        if task_type is not UNSET:
-            field_dict["task_type"] = task_type
-        if processing_mode is not UNSET:
-            field_dict["processing_mode"] = processing_mode
-        if join_with_input is not UNSET:
-            field_dict["join_with_input"] = join_with_input
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        from ..models.multi_agent_query_params import MultiAgentQueryParams
-
-        d = dict(src_dict)
-        query = MultiAgentQueryParams.from_dict(d.pop("query"))
-
-        def _parse_input_artifacts(data: object) -> list[UUID] | None | Unset:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, list):
-                    raise TypeError()
-                input_artifacts_type_0 = []
-                _input_artifacts_type_0 = data
-                for componentsschemas_input_artifacts_ids_item_data in _input_artifacts_type_0:
-                    componentsschemas_input_artifacts_ids_item = UUID(componentsschemas_input_artifacts_ids_item_data)
-
-                    input_artifacts_type_0.append(componentsschemas_input_artifacts_ids_item)
-
-                return input_artifacts_type_0
-            except (TypeError, ValueError, AttributeError, KeyError):
-                pass
-            return cast(list[UUID] | None | Unset, data)
-
-        input_artifacts = _parse_input_artifacts(d.pop("input_artifacts", UNSET))
-
-        def _parse_context_artifacts(data: object) -> list[UUID] | None | Unset:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, list):
-                    raise TypeError()
-                context_artifacts_type_0 = []
-                _context_artifacts_type_0 = data
-                for componentsschemas_context_artifacts_ids_item_data in _context_artifacts_type_0:
-                    componentsschemas_context_artifacts_ids_item = UUID(
-                        componentsschemas_context_artifacts_ids_item_data
-                    )
-
-                    context_artifacts_type_0.append(componentsschemas_context_artifacts_ids_item)
-
-                return context_artifacts_type_0
-            except (TypeError, ValueError, AttributeError, KeyError):
-                pass
-            return cast(list[UUID] | None | Unset, data)
-
-        context_artifacts = _parse_context_artifacts(d.pop("context_artifacts", 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_task_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()
-                task_id_type_0 = UUID(data)
-
-                return task_id_type_0
-            except (TypeError, ValueError, AttributeError, KeyError):
-                pass
-            return cast(None | Unset | UUID, data)
-
-        task_id = _parse_task_id(d.pop("task_id", UNSET))
-
-        def _parse_replaces_task_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()
-                replaces_task_id_type_0 = UUID(data)
-
-                return replaces_task_id_type_0
-            except (TypeError, ValueError, AttributeError, KeyError):
-                pass
-            return cast(None | Unset | UUID, data)
-
-        replaces_task_id = _parse_replaces_task_id(d.pop("replaces_task_id", UNSET))
-
-        def _parse_twin_artifact_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()
-                twin_artifact_id_type_0 = UUID(data)
-
-                return twin_artifact_id_type_0
-            except (TypeError, ValueError, AttributeError, KeyError):
-                pass
-            return cast(None | Unset | UUID, data)
-
-        twin_artifact_id = _parse_twin_artifact_id(d.pop("twin_artifact_id", UNSET))
-
-        task_type = cast(Literal["multiagent"] | Unset, d.pop("task_type", UNSET))
-        if task_type != "multiagent" and not isinstance(task_type, Unset):
-            raise ValueError(f"task_type must match const 'multiagent', got '{task_type}'")
-
-        processing_mode = cast(Literal["map"] | Unset, d.pop("processing_mode", UNSET))
-        if processing_mode != "map" and not isinstance(processing_mode, Unset):
-            raise ValueError(f"processing_mode must match const 'map', got '{processing_mode}'")
-
-        join_with_input = d.pop("join_with_input", UNSET)
-
-        map_multi_agent_request_params = cls(
-            query=query,
-            input_artifacts=input_artifacts,
-            context_artifacts=context_artifacts,
-            label=label,
-            description=description,
-            task_id=task_id,
-            replaces_task_id=replaces_task_id,
-            twin_artifact_id=twin_artifact_id,
-            task_type=task_type,
-            processing_mode=processing_mode,
-            join_with_input=join_with_input,
-        )
-
-        map_multi_agent_request_params.additional_properties = d
-        return map_multi_agent_request_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/message_created_payload.py

@@ -1,98 +0,0 @@
-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_query_params.py

@@ -1,264 +0,0 @@
-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