langwatch-scenario 0.4.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/put_api_prompts_by_id_response_400.py

@@ -0,0 +1,61 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.put_api_prompts_by_id_response_400_error import PutApiPromptsByIdResponse400Error
+
+T = TypeVar("T", bound="PutApiPromptsByIdResponse400")
+
+
+@_attrs_define
+class PutApiPromptsByIdResponse400:
+    """
+    Attributes:
+        error (PutApiPromptsByIdResponse400Error):
+    """
+
+    error: PutApiPromptsByIdResponse400Error
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = PutApiPromptsByIdResponse400Error(d.pop("error"))
+
+        put_api_prompts_by_id_response_400 = cls(
+            error=error,
+        )
+
+        put_api_prompts_by_id_response_400.additional_properties = d
+        return put_api_prompts_by_id_response_400
+
+    @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

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/put_api_prompts_by_id_response_400_error.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class PutApiPromptsByIdResponse400Error(str, Enum):
+    BAD_REQUEST = "Bad Request"
+
+    def __str__(self) -> str:
+        return str(self.value)

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/put_api_prompts_by_id_response_401.py

@@ -0,0 +1,61 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.put_api_prompts_by_id_response_401_error import PutApiPromptsByIdResponse401Error
+
+T = TypeVar("T", bound="PutApiPromptsByIdResponse401")
+
+
+@_attrs_define
+class PutApiPromptsByIdResponse401:
+    """
+    Attributes:
+        error (PutApiPromptsByIdResponse401Error):
+    """
+
+    error: PutApiPromptsByIdResponse401Error
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = PutApiPromptsByIdResponse401Error(d.pop("error"))
+
+        put_api_prompts_by_id_response_401 = cls(
+            error=error,
+        )
+
+        put_api_prompts_by_id_response_401.additional_properties = d
+        return put_api_prompts_by_id_response_401
+
+    @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

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/put_api_prompts_by_id_response_401_error.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class PutApiPromptsByIdResponse401Error(str, Enum):
+    UNAUTHORIZED = "Unauthorized"
+
+    def __str__(self) -> str:
+        return str(self.value)

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/put_api_prompts_by_id_response_404.py

@@ -0,0 +1,59 @@
+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="PutApiPromptsByIdResponse404")
+
+
+@_attrs_define
+class PutApiPromptsByIdResponse404:
+    """
+    Attributes:
+        error (str):
+    """
+
+    error: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = d.pop("error")
+
+        put_api_prompts_by_id_response_404 = cls(
+            error=error,
+        )
+
+        put_api_prompts_by_id_response_404.additional_properties = d
+        return put_api_prompts_by_id_response_404
+
+    @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

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/put_api_prompts_by_id_response_500.py

@@ -0,0 +1,59 @@
+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="PutApiPromptsByIdResponse500")
+
+
+@_attrs_define
+class PutApiPromptsByIdResponse500:
+    """
+    Attributes:
+        error (str):
+    """
+
+    error: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = d.pop("error")
+
+        put_api_prompts_by_id_response_500 = cls(
+            error=error,
+        )
+
+        put_api_prompts_by_id_response_500.additional_properties = d
+        return put_api_prompts_by_id_response_500
+
+    @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

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/search_request.py

@@ -0,0 +1,133 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.search_request_filters import SearchRequestFilters
+
+
+T = TypeVar("T", bound="SearchRequest")
+
+
+@_attrs_define
+class SearchRequest:
+    """
+    Attributes:
+        query (Union[Unset, str]):
+        start_date (Union[Unset, datetime.datetime]):
+        end_date (Union[Unset, datetime.datetime]):
+        page_size (Union[Unset, int]):  Example: 1000.
+        scroll_id (Union[Unset, str]):  Example: 123.
+        filters (Union[Unset, SearchRequestFilters]):
+    """
+
+    query: Union[Unset, str] = UNSET
+    start_date: Union[Unset, datetime.datetime] = UNSET
+    end_date: Union[Unset, datetime.datetime] = UNSET
+    page_size: Union[Unset, int] = UNSET
+    scroll_id: Union[Unset, str] = UNSET
+    filters: Union[Unset, "SearchRequestFilters"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query
+
+        start_date: Union[Unset, str] = UNSET
+        if not isinstance(self.start_date, Unset):
+            start_date = self.start_date.isoformat()
+
+        end_date: Union[Unset, str] = UNSET
+        if not isinstance(self.end_date, Unset):
+            end_date = self.end_date.isoformat()
+
+        page_size = self.page_size
+
+        scroll_id = self.scroll_id
+
+        filters: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.filters, Unset):
+            filters = self.filters.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if query is not UNSET:
+            field_dict["query"] = query
+        if start_date is not UNSET:
+            field_dict["startDate"] = start_date
+        if end_date is not UNSET:
+            field_dict["endDate"] = end_date
+        if page_size is not UNSET:
+            field_dict["pageSize"] = page_size
+        if scroll_id is not UNSET:
+            field_dict["scrollId"] = scroll_id
+        if filters is not UNSET:
+            field_dict["filters"] = filters
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.search_request_filters import SearchRequestFilters
+
+        d = dict(src_dict)
+        query = d.pop("query", UNSET)
+
+        _start_date = d.pop("startDate", UNSET)
+        start_date: Union[Unset, datetime.datetime]
+        if isinstance(_start_date, Unset):
+            start_date = UNSET
+        else:
+            start_date = isoparse(_start_date)
+
+        _end_date = d.pop("endDate", UNSET)
+        end_date: Union[Unset, datetime.datetime]
+        if isinstance(_end_date, Unset):
+            end_date = UNSET
+        else:
+            end_date = isoparse(_end_date)
+
+        page_size = d.pop("pageSize", UNSET)
+
+        scroll_id = d.pop("scrollId", UNSET)
+
+        _filters = d.pop("filters", UNSET)
+        filters: Union[Unset, SearchRequestFilters]
+        if isinstance(_filters, Unset):
+            filters = UNSET
+        else:
+            filters = SearchRequestFilters.from_dict(_filters)
+
+        search_request = cls(
+            query=query,
+            start_date=start_date,
+            end_date=end_date,
+            page_size=page_size,
+            scroll_id=scroll_id,
+            filters=filters,
+        )
+
+        search_request.additional_properties = d
+        return search_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

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/search_request_filters.py

@@ -0,0 +1,51 @@
+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
+
+T = TypeVar("T", bound="SearchRequestFilters")
+
+
+@_attrs_define
+class SearchRequestFilters:
+    """ """
+
+    additional_properties: dict[str, list[str]] = _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
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        search_request_filters = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = cast(list[str], prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        search_request_filters.additional_properties = additional_properties
+        return search_request_filters
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[str]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[str]) -> 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

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/search_response.py

@@ -0,0 +1,93 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.pagination import Pagination
+    from ..models.trace import Trace
+
+
+T = TypeVar("T", bound="SearchResponse")
+
+
+@_attrs_define
+class SearchResponse:
+    """
+    Attributes:
+        traces (Union[Unset, list['Trace']]):
+        pagination (Union[Unset, Pagination]):
+    """
+
+    traces: Union[Unset, list["Trace"]] = UNSET
+    pagination: Union[Unset, "Pagination"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        traces: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.traces, Unset):
+            traces = []
+            for traces_item_data in self.traces:
+                traces_item = traces_item_data.to_dict()
+                traces.append(traces_item)
+
+        pagination: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.pagination, Unset):
+            pagination = self.pagination.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if traces is not UNSET:
+            field_dict["traces"] = traces
+        if pagination is not UNSET:
+            field_dict["pagination"] = pagination
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.pagination import Pagination
+        from ..models.trace import Trace
+
+        d = dict(src_dict)
+        traces = []
+        _traces = d.pop("traces", UNSET)
+        for traces_item_data in _traces or []:
+            traces_item = Trace.from_dict(traces_item_data)
+
+            traces.append(traces_item)
+
+        _pagination = d.pop("pagination", UNSET)
+        pagination: Union[Unset, Pagination]
+        if isinstance(_pagination, Unset):
+            pagination = UNSET
+        else:
+            pagination = Pagination.from_dict(_pagination)
+
+        search_response = cls(
+            traces=traces,
+            pagination=pagination,
+        )
+
+        search_response.additional_properties = d
+        return search_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/timestamps.py

@@ -0,0 +1,77 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Timestamps")
+
+
+@_attrs_define
+class Timestamps:
+    """
+    Attributes:
+        inserted_at (Union[Unset, int]):
+        started_at (Union[Unset, int]):
+        updated_at (Union[Unset, int]):
+    """
+
+    inserted_at: Union[Unset, int] = UNSET
+    started_at: Union[Unset, int] = UNSET
+    updated_at: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        inserted_at = self.inserted_at
+
+        started_at = self.started_at
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if inserted_at is not UNSET:
+            field_dict["inserted_at"] = inserted_at
+        if started_at is not UNSET:
+            field_dict["started_at"] = started_at
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        inserted_at = d.pop("inserted_at", UNSET)
+
+        started_at = d.pop("started_at", UNSET)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        timestamps = cls(
+            inserted_at=inserted_at,
+            started_at=started_at,
+            updated_at=updated_at,
+        )
+
+        timestamps.additional_properties = d
+        return timestamps
+
+    @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