everyrow 0.1.0__py3-none-any.whl

everyrow/generated/models/simple_chat_message.py

@@ -0,0 +1,121 @@
+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 ..models.simple_chat_message_role import SimpleChatMessageRole
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SimpleChatMessage")
+
+
+@_attrs_define
+class SimpleChatMessage:
+    """
+    Attributes:
+        content (str):
+        role (SimpleChatMessageRole):
+        message_type (Literal['simple'] | Unset):  Default: 'simple'.
+        completion_tokens (int | None | Unset):
+        cacheable (bool | Unset):  Default: False.
+        explicit_cache_breakpoint (bool | Unset):  Default: False.
+    """
+
+    content: str
+    role: SimpleChatMessageRole
+    message_type: Literal["simple"] | Unset = "simple"
+    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]:
+        content = self.content
+
+        role = self.role.value
+
+        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(
+            {
+                "content": content,
+                "role": role,
+            }
+        )
+        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:
+        d = dict(src_dict)
+        content = d.pop("content")
+
+        role = SimpleChatMessageRole(d.pop("role"))
+
+        message_type = cast(Literal["simple"] | Unset, d.pop("message_type", UNSET))
+        if message_type != "simple" and not isinstance(message_type, Unset):
+            raise ValueError(f"message_type must match const 'simple', 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)
+
+        simple_chat_message = cls(
+            content=content,
+            role=role,
+            message_type=message_type,
+            completion_tokens=completion_tokens,
+            cacheable=cacheable,
+            explicit_cache_breakpoint=explicit_cache_breakpoint,
+        )
+
+        simple_chat_message.additional_properties = d
+        return simple_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/simple_chat_message_role.py

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

everyrow/generated/models/simple_chat_message_with_tool_calls.py

@@ -0,0 +1,156 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.chat_completion_message_tool_call import ChatCompletionMessageToolCall
+
+
+T = TypeVar("T", bound="SimpleChatMessageWithToolCalls")
+
+
+@_attrs_define
+class SimpleChatMessageWithToolCalls:
+    """
+    Attributes:
+        role (Literal['assistant']):
+        tool_calls (list[ChatCompletionMessageToolCall]):
+        message_type (Literal['simple_with_tool_calls'] | Unset):  Default: 'simple_with_tool_calls'.
+        content (None | str | Unset):
+        completion_tokens (int | None | Unset):
+        cacheable (bool | Unset):  Default: False.
+        explicit_cache_breakpoint (bool | Unset):  Default: False.
+    """
+
+    role: Literal["assistant"]
+    tool_calls: list[ChatCompletionMessageToolCall]
+    message_type: Literal["simple_with_tool_calls"] | Unset = "simple_with_tool_calls"
+    content: None | str | Unset = UNSET
+    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]:
+        role = self.role
+
+        tool_calls = []
+        for tool_calls_item_data in self.tool_calls:
+            tool_calls_item = tool_calls_item_data.to_dict()
+            tool_calls.append(tool_calls_item)
+
+        message_type = self.message_type
+
+        content: None | str | Unset
+        if isinstance(self.content, Unset):
+            content = UNSET
+        else:
+            content = self.content
+
+        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,
+                "tool_calls": tool_calls,
+            }
+        )
+        if message_type is not UNSET:
+            field_dict["message_type"] = message_type
+        if content is not UNSET:
+            field_dict["content"] = content
+        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.chat_completion_message_tool_call import ChatCompletionMessageToolCall
+
+        d = dict(src_dict)
+        role = cast(Literal["assistant"], d.pop("role"))
+        if role != "assistant":
+            raise ValueError(f"role must match const 'assistant', got '{role}'")
+
+        tool_calls = []
+        _tool_calls = d.pop("tool_calls")
+        for tool_calls_item_data in _tool_calls:
+            tool_calls_item = ChatCompletionMessageToolCall.from_dict(tool_calls_item_data)
+
+            tool_calls.append(tool_calls_item)
+
+        message_type = cast(Literal["simple_with_tool_calls"] | Unset, d.pop("message_type", UNSET))
+        if message_type != "simple_with_tool_calls" and not isinstance(message_type, Unset):
+            raise ValueError(f"message_type must match const 'simple_with_tool_calls', got '{message_type}'")
+
+        def _parse_content(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        content = _parse_content(d.pop("content", UNSET))
+
+        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)
+
+        simple_chat_message_with_tool_calls = cls(
+            role=role,
+            tool_calls=tool_calls,
+            message_type=message_type,
+            content=content,
+            completion_tokens=completion_tokens,
+            cacheable=cacheable,
+            explicit_cache_breakpoint=explicit_cache_breakpoint,
+        )
+
+        simple_chat_message_with_tool_calls.additional_properties = d
+        return simple_chat_message_with_tool_calls
+
+    @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/source_database_entry.py

@@ -0,0 +1,92 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SourceDatabaseEntry")
+
+
+@_attrs_define
+class SourceDatabaseEntry:
+    """Simplified version of toolkit.agents.source_bank.SourceBase for the database.
+
+    Attributes:
+        url (str):
+        content_summary (str):
+        title (None | str | Unset):
+    """
+
+    url: str
+    content_summary: str
+    title: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        content_summary = self.content_summary
+
+        title: None | str | Unset
+        if isinstance(self.title, Unset):
+            title = UNSET
+        else:
+            title = self.title
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+                "content_summary": content_summary,
+            }
+        )
+        if title is not UNSET:
+            field_dict["title"] = title
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        content_summary = d.pop("content_summary")
+
+        def _parse_title(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        title = _parse_title(d.pop("title", UNSET))
+
+        source_database_entry = cls(
+            url=url,
+            content_summary=content_summary,
+            title=title,
+        )
+
+        source_database_entry.additional_properties = d
+        return source_database_entry
+
+    @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/standalone_artifact_record.py

@@ -0,0 +1,278 @@
+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 ..models.artifact_status import ArtifactStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.aux_data import AuxData
+    from ..models.standalone_artifact_record_metadata_type_0 import StandaloneArtifactRecordMetadataType0
+    from ..models.standalone_artifact_record_trace_mapping_type_0 import StandaloneArtifactRecordTraceMappingType0
+
+
+T = TypeVar("T", bound="StandaloneArtifactRecord")
+
+
+@_attrs_define
+class StandaloneArtifactRecord:
+    """
+    Attributes:
+        uid (UUID):
+        type_ (Literal['standalone']):
+        data (Any):
+        metadata (None | StandaloneArtifactRecordMetadataType0 | Unset):
+        label (None | str | Unset):
+        aux_data (AuxData | Unset):
+        status (ArtifactStatus | Unset):
+        trace_mapping (None | StandaloneArtifactRecordTraceMappingType0 | Unset):
+        original_id (None | Unset | UUID):
+        index_in_group (int | None | Unset):
+        current_iteration (int | None | Unset):
+    """
+
+    uid: UUID
+    type_: Literal["standalone"]
+    data: Any
+    metadata: None | StandaloneArtifactRecordMetadataType0 | Unset = UNSET
+    label: None | str | Unset = UNSET
+    aux_data: AuxData | Unset = UNSET
+    status: ArtifactStatus | Unset = UNSET
+    trace_mapping: None | StandaloneArtifactRecordTraceMappingType0 | Unset = UNSET
+    original_id: None | Unset | UUID = UNSET
+    index_in_group: int | None | Unset = UNSET
+    current_iteration: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.standalone_artifact_record_metadata_type_0 import StandaloneArtifactRecordMetadataType0
+        from ..models.standalone_artifact_record_trace_mapping_type_0 import StandaloneArtifactRecordTraceMappingType0
+
+        uid = str(self.uid)
+
+        type_ = self.type_
+
+        data = self.data
+
+        metadata: dict[str, Any] | None | Unset
+        if isinstance(self.metadata, Unset):
+            metadata = UNSET
+        elif isinstance(self.metadata, StandaloneArtifactRecordMetadataType0):
+            metadata = self.metadata.to_dict()
+        else:
+            metadata = self.metadata
+
+        label: None | str | Unset
+        if isinstance(self.label, Unset):
+            label = UNSET
+        else:
+            label = self.label
+
+        aux_data: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.aux_data, Unset):
+            aux_data = self.aux_data.to_dict()
+
+        status: str | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+        trace_mapping: dict[str, Any] | None | Unset
+        if isinstance(self.trace_mapping, Unset):
+            trace_mapping = UNSET
+        elif isinstance(self.trace_mapping, StandaloneArtifactRecordTraceMappingType0):
+            trace_mapping = self.trace_mapping.to_dict()
+        else:
+            trace_mapping = self.trace_mapping
+
+        original_id: None | str | Unset
+        if isinstance(self.original_id, Unset):
+            original_id = UNSET
+        elif isinstance(self.original_id, UUID):
+            original_id = str(self.original_id)
+        else:
+            original_id = self.original_id
+
+        index_in_group: int | None | Unset
+        if isinstance(self.index_in_group, Unset):
+            index_in_group = UNSET
+        else:
+            index_in_group = self.index_in_group
+
+        current_iteration: int | None | Unset
+        if isinstance(self.current_iteration, Unset):
+            current_iteration = UNSET
+        else:
+            current_iteration = self.current_iteration
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uid": uid,
+                "type": type_,
+                "data": data,
+            }
+        )
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if label is not UNSET:
+            field_dict["label"] = label
+        if aux_data is not UNSET:
+            field_dict["aux_data"] = aux_data
+        if status is not UNSET:
+            field_dict["status"] = status
+        if trace_mapping is not UNSET:
+            field_dict["trace_mapping"] = trace_mapping
+        if original_id is not UNSET:
+            field_dict["original_id"] = original_id
+        if index_in_group is not UNSET:
+            field_dict["index_in_group"] = index_in_group
+        if current_iteration is not UNSET:
+            field_dict["current_iteration"] = current_iteration
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.aux_data import AuxData
+        from ..models.standalone_artifact_record_metadata_type_0 import StandaloneArtifactRecordMetadataType0
+        from ..models.standalone_artifact_record_trace_mapping_type_0 import StandaloneArtifactRecordTraceMappingType0
+
+        d = dict(src_dict)
+        uid = UUID(d.pop("uid"))
+
+        type_ = cast(Literal["standalone"], d.pop("type"))
+        if type_ != "standalone":
+            raise ValueError(f"type must match const 'standalone', got '{type_}'")
+
+        data = d.pop("data")
+
+        def _parse_metadata(data: object) -> None | StandaloneArtifactRecordMetadataType0 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                metadata_type_0 = StandaloneArtifactRecordMetadataType0.from_dict(data)
+
+                return metadata_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | StandaloneArtifactRecordMetadataType0 | Unset, data)
+
+        metadata = _parse_metadata(d.pop("metadata", 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))
+
+        _aux_data = d.pop("aux_data", UNSET)
+        aux_data: AuxData | Unset
+        if isinstance(_aux_data, Unset):
+            aux_data = UNSET
+        else:
+            aux_data = AuxData.from_dict(_aux_data)
+
+        _status = d.pop("status", UNSET)
+        status: ArtifactStatus | Unset
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = ArtifactStatus(_status)
+
+        def _parse_trace_mapping(data: object) -> None | StandaloneArtifactRecordTraceMappingType0 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                trace_mapping_type_0 = StandaloneArtifactRecordTraceMappingType0.from_dict(data)
+
+                return trace_mapping_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | StandaloneArtifactRecordTraceMappingType0 | Unset, data)
+
+        trace_mapping = _parse_trace_mapping(d.pop("trace_mapping", UNSET))
+
+        def _parse_original_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()
+                original_id_type_0 = UUID(data)
+
+                return original_id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        original_id = _parse_original_id(d.pop("original_id", UNSET))
+
+        def _parse_index_in_group(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        index_in_group = _parse_index_in_group(d.pop("index_in_group", UNSET))
+
+        def _parse_current_iteration(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        current_iteration = _parse_current_iteration(d.pop("current_iteration", UNSET))
+
+        standalone_artifact_record = cls(
+            uid=uid,
+            type_=type_,
+            data=data,
+            metadata=metadata,
+            label=label,
+            aux_data=aux_data,
+            status=status,
+            trace_mapping=trace_mapping,
+            original_id=original_id,
+            index_in_group=index_in_group,
+            current_iteration=current_iteration,
+        )
+
+        standalone_artifact_record.additional_properties = d
+        return standalone_artifact_record
+
+    @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/standalone_artifact_record_metadata_type_0.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="StandaloneArtifactRecordMetadataType0")
+
+
+@_attrs_define
+class StandaloneArtifactRecordMetadataType0:
+    """ """
+
+    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)
+        standalone_artifact_record_metadata_type_0 = cls()
+
+        standalone_artifact_record_metadata_type_0.additional_properties = d
+        return standalone_artifact_record_metadata_type_0
+
+    @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