langwatch-scenario 0.6.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

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

@@ -0,0 +1,68 @@
+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="GetApiTraceIdResponse200SpansItemOutputValueItem")
+
+
+@_attrs_define
+class GetApiTraceIdResponse200SpansItemOutputValueItem:
+    """
+    Attributes:
+        role (Union[Unset, str]):  Example: assistant.
+        content (Union[Unset, str]):  Example: Hey there! 👋😊.
+    """
+
+    role: Union[Unset, str] = UNSET
+    content: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role
+
+        content = self.content
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if role is not UNSET:
+            field_dict["role"] = role
+        if content is not UNSET:
+            field_dict["content"] = content
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        role = d.pop("role", UNSET)
+
+        content = d.pop("content", UNSET)
+
+        get_api_trace_id_response_200_spans_item_output_value_item = cls(
+            role=role,
+            content=content,
+        )
+
+        get_api_trace_id_response_200_spans_item_output_value_item.additional_properties = d
+        return get_api_trace_id_response_200_spans_item_output_value_item
+
+    @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/get_api_trace_id_response_200_spans_item_params.py

@@ -0,0 +1,68 @@
+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="GetApiTraceIdResponse200SpansItemParams")
+
+
+@_attrs_define
+class GetApiTraceIdResponse200SpansItemParams:
+    """
+    Attributes:
+        stream (Union[Unset, bool]):  Example: True.
+        temperature (Union[Unset, float]):  Example: 1.
+    """
+
+    stream: Union[Unset, bool] = UNSET
+    temperature: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        stream = self.stream
+
+        temperature = self.temperature
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if stream is not UNSET:
+            field_dict["stream"] = stream
+        if temperature is not UNSET:
+            field_dict["temperature"] = temperature
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        stream = d.pop("stream", UNSET)
+
+        temperature = d.pop("temperature", UNSET)
+
+        get_api_trace_id_response_200_spans_item_params = cls(
+            stream=stream,
+            temperature=temperature,
+        )
+
+        get_api_trace_id_response_200_spans_item_params.additional_properties = d
+        return get_api_trace_id_response_200_spans_item_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

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

@@ -0,0 +1,95 @@
+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="GetApiTraceIdResponse200SpansItemTimestamps")
+
+
+@_attrs_define
+class GetApiTraceIdResponse200SpansItemTimestamps:
+    """
+    Attributes:
+        finished_at (Union[Unset, int]):  Example: 1721382488392.
+        updated_at (Union[Unset, int]):  Example: 1721382492027.
+        started_at (Union[Unset, int]):  Example: 1721382486895.
+        first_token_at (Union[Unset, int]):  Example: 1721382488317.
+        inserted_at (Union[Unset, int]):  Example: 1721382492027.
+    """
+
+    finished_at: Union[Unset, int] = UNSET
+    updated_at: Union[Unset, int] = UNSET
+    started_at: Union[Unset, int] = UNSET
+    first_token_at: Union[Unset, int] = UNSET
+    inserted_at: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        finished_at = self.finished_at
+
+        updated_at = self.updated_at
+
+        started_at = self.started_at
+
+        first_token_at = self.first_token_at
+
+        inserted_at = self.inserted_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if finished_at is not UNSET:
+            field_dict["finished_at"] = finished_at
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+        if started_at is not UNSET:
+            field_dict["started_at"] = started_at
+        if first_token_at is not UNSET:
+            field_dict["first_token_at"] = first_token_at
+        if inserted_at is not UNSET:
+            field_dict["inserted_at"] = inserted_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        finished_at = d.pop("finished_at", UNSET)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        started_at = d.pop("started_at", UNSET)
+
+        first_token_at = d.pop("first_token_at", UNSET)
+
+        inserted_at = d.pop("inserted_at", UNSET)
+
+        get_api_trace_id_response_200_spans_item_timestamps = cls(
+            finished_at=finished_at,
+            updated_at=updated_at,
+            started_at=started_at,
+            first_token_at=first_token_at,
+            inserted_at=inserted_at,
+        )
+
+        get_api_trace_id_response_200_spans_item_timestamps.additional_properties = d
+        return get_api_trace_id_response_200_spans_item_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

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/get_api_trace_id_response_200_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="GetApiTraceIdResponse200Timestamps")
+
+
+@_attrs_define
+class GetApiTraceIdResponse200Timestamps:
+    """
+    Attributes:
+        started_at (Union[Unset, int]):  Example: 1721382486868.
+        inserted_at (Union[Unset, int]):  Example: 1721382492894.
+        updated_at (Union[Unset, int]):  Example: 1721382492894.
+    """
+
+    started_at: Union[Unset, int] = UNSET
+    inserted_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]:
+        started_at = self.started_at
+
+        inserted_at = self.inserted_at
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if started_at is not UNSET:
+            field_dict["started_at"] = started_at
+        if inserted_at is not UNSET:
+            field_dict["inserted_at"] = inserted_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)
+        started_at = d.pop("started_at", UNSET)
+
+        inserted_at = d.pop("inserted_at", UNSET)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        get_api_trace_id_response_200_timestamps = cls(
+            started_at=started_at,
+            inserted_at=inserted_at,
+            updated_at=updated_at,
+        )
+
+        get_api_trace_id_response_200_timestamps.additional_properties = d
+        return get_api_trace_id_response_200_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

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

@@ -0,0 +1,68 @@
+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="Input")
+
+
+@_attrs_define
+class Input:
+    """
+    Attributes:
+        value (Union[Unset, str]):
+        satisfaction_score (Union[Unset, float]):
+    """
+
+    value: Union[Unset, str] = UNSET
+    satisfaction_score: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = self.value
+
+        satisfaction_score = self.satisfaction_score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if value is not UNSET:
+            field_dict["value"] = value
+        if satisfaction_score is not UNSET:
+            field_dict["satisfaction_score"] = satisfaction_score
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        value = d.pop("value", UNSET)
+
+        satisfaction_score = d.pop("satisfaction_score", UNSET)
+
+        input_ = cls(
+            value=value,
+            satisfaction_score=satisfaction_score,
+        )
+
+        input_.additional_properties = d
+        return input_
+
+    @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/metadata.py

@@ -0,0 +1,68 @@
+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="Metadata")
+
+
+@_attrs_define
+class Metadata:
+    """
+    Attributes:
+        sdk_language (Union[Unset, str]):
+        sdk_version (Union[Unset, str]):
+    """
+
+    sdk_language: Union[Unset, str] = UNSET
+    sdk_version: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        sdk_language = self.sdk_language
+
+        sdk_version = self.sdk_version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if sdk_language is not UNSET:
+            field_dict["sdk_language"] = sdk_language
+        if sdk_version is not UNSET:
+            field_dict["sdk_version"] = sdk_version
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        sdk_language = d.pop("sdk_language", UNSET)
+
+        sdk_version = d.pop("sdk_version", UNSET)
+
+        metadata = cls(
+            sdk_language=sdk_language,
+            sdk_version=sdk_version,
+        )
+
+        metadata.additional_properties = d
+        return 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

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

@@ -0,0 +1,115 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Metrics")
+
+
+@_attrs_define
+class Metrics:
+    """
+    Attributes:
+        tokens_estimated (Union[Unset, bool]):
+        completion_tokens (Union[Unset, int]):
+        prompt_tokens (Union[Unset, int]):
+        total_cost (Union[Unset, float]):
+        total_time_ms (Union[Unset, int]):
+        first_token_ms (Union[None, Unset, int]):
+    """
+
+    tokens_estimated: Union[Unset, bool] = UNSET
+    completion_tokens: Union[Unset, int] = UNSET
+    prompt_tokens: Union[Unset, int] = UNSET
+    total_cost: Union[Unset, float] = UNSET
+    total_time_ms: Union[Unset, int] = UNSET
+    first_token_ms: Union[None, Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tokens_estimated = self.tokens_estimated
+
+        completion_tokens = self.completion_tokens
+
+        prompt_tokens = self.prompt_tokens
+
+        total_cost = self.total_cost
+
+        total_time_ms = self.total_time_ms
+
+        first_token_ms: Union[None, Unset, int]
+        if isinstance(self.first_token_ms, Unset):
+            first_token_ms = UNSET
+        else:
+            first_token_ms = self.first_token_ms
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if tokens_estimated is not UNSET:
+            field_dict["tokens_estimated"] = tokens_estimated
+        if completion_tokens is not UNSET:
+            field_dict["completion_tokens"] = completion_tokens
+        if prompt_tokens is not UNSET:
+            field_dict["prompt_tokens"] = prompt_tokens
+        if total_cost is not UNSET:
+            field_dict["total_cost"] = total_cost
+        if total_time_ms is not UNSET:
+            field_dict["total_time_ms"] = total_time_ms
+        if first_token_ms is not UNSET:
+            field_dict["first_token_ms"] = first_token_ms
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        tokens_estimated = d.pop("tokens_estimated", UNSET)
+
+        completion_tokens = d.pop("completion_tokens", UNSET)
+
+        prompt_tokens = d.pop("prompt_tokens", UNSET)
+
+        total_cost = d.pop("total_cost", UNSET)
+
+        total_time_ms = d.pop("total_time_ms", UNSET)
+
+        def _parse_first_token_ms(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        first_token_ms = _parse_first_token_ms(d.pop("first_token_ms", UNSET))
+
+        metrics = cls(
+            tokens_estimated=tokens_estimated,
+            completion_tokens=completion_tokens,
+            prompt_tokens=prompt_tokens,
+            total_cost=total_cost,
+            total_time_ms=total_time_ms,
+            first_token_ms=first_token_ms,
+        )
+
+        metrics.additional_properties = d
+        return metrics
+
+    @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/output.py

@@ -0,0 +1,59 @@
+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="Output")
+
+
+@_attrs_define
+class Output:
+    """
+    Attributes:
+        value (Union[Unset, str]):
+    """
+
+    value: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if value is not UNSET:
+            field_dict["value"] = value
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        value = d.pop("value", UNSET)
+
+        output = cls(
+            value=value,
+        )
+
+        output.additional_properties = d
+        return output
+
+    @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/pagination.py

@@ -0,0 +1,68 @@
+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="Pagination")
+
+
+@_attrs_define
+class Pagination:
+    """
+    Attributes:
+        scroll_id (Union[Unset, str]):  Example: 123.
+        total_hits (Union[Unset, int]):  Example: 1254.
+    """
+
+    scroll_id: Union[Unset, str] = UNSET
+    total_hits: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        scroll_id = self.scroll_id
+
+        total_hits = self.total_hits
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if scroll_id is not UNSET:
+            field_dict["scrollId"] = scroll_id
+        if total_hits is not UNSET:
+            field_dict["totalHits"] = total_hits
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        scroll_id = d.pop("scrollId", UNSET)
+
+        total_hits = d.pop("totalHits", UNSET)
+
+        pagination = cls(
+            scroll_id=scroll_id,
+            total_hits=total_hits,
+        )
+
+        pagination.additional_properties = d
+        return pagination
+
+    @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