blaxel 0.2.34__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/client/models/store_configuration.py

@@ -1,156 +0,0 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union, 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.store_configuration_option import StoreConfigurationOption
-
-
-T = TypeVar("T", bound="StoreConfiguration")
-
-
-@_attrs_define
-class StoreConfiguration:
-    """Store configuration for resources (eg: agent, function, etc)
-
-    Attributes:
-        available_models (Union[Unset, list[str]]): Available models for the configuration
-        description (Union[Unset, str]): Store configuration description
-        display_name (Union[Unset, str]): Store configuration display name
-        if_ (Union[Unset, str]): Conditional rendering for the configuration, example: provider === 'openai'
-        name (Union[Unset, str]): Store configuration name
-        options (Union[Unset, list['StoreConfigurationOption']]):
-        required (Union[Unset, bool]): Store configuration required
-        secret (Union[Unset, bool]): Store configuration secret
-        type_ (Union[Unset, str]): Store configuration type
-    """
-
-    available_models: Union[Unset, list[str]] = UNSET
-    description: Union[Unset, str] = UNSET
-    display_name: Union[Unset, str] = UNSET
-    if_: Union[Unset, str] = UNSET
-    name: Union[Unset, str] = UNSET
-    options: Union[Unset, list["StoreConfigurationOption"]] = UNSET
-    required: Union[Unset, bool] = UNSET
-    secret: Union[Unset, bool] = UNSET
-    type_: Union[Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        available_models: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.available_models, Unset):
-            available_models = self.available_models
-
-        description = self.description
-
-        display_name = self.display_name
-
-        if_ = self.if_
-
-        name = self.name
-
-        options: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.options, Unset):
-            options = []
-            for options_item_data in self.options:
-                if type(options_item_data) is dict:
-                    options_item = options_item_data
-                else:
-                    options_item = options_item_data.to_dict()
-                options.append(options_item)
-
-        required = self.required
-
-        secret = self.secret
-
-        type_ = self.type_
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if available_models is not UNSET:
-            field_dict["availableModels"] = available_models
-        if description is not UNSET:
-            field_dict["description"] = description
-        if display_name is not UNSET:
-            field_dict["displayName"] = display_name
-        if if_ is not UNSET:
-            field_dict["if"] = if_
-        if name is not UNSET:
-            field_dict["name"] = name
-        if options is not UNSET:
-            field_dict["options"] = options
-        if required is not UNSET:
-            field_dict["required"] = required
-        if secret is not UNSET:
-            field_dict["secret"] = secret
-        if type_ is not UNSET:
-            field_dict["type"] = type_
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.store_configuration_option import StoreConfigurationOption
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        available_models = cast(
-            list[str], d.pop("availableModels", d.pop("available_models", UNSET))
-        )
-
-        description = d.pop("description", UNSET)
-
-        display_name = d.pop("displayName", d.pop("display_name", UNSET))
-
-        if_ = d.pop("if", d.pop("if_", UNSET))
-
-        name = d.pop("name", UNSET)
-
-        options = []
-        _options = d.pop("options", UNSET)
-        for options_item_data in _options or []:
-            options_item = StoreConfigurationOption.from_dict(options_item_data)
-
-            options.append(options_item)
-
-        required = d.pop("required", UNSET)
-
-        secret = d.pop("secret", UNSET)
-
-        type_ = d.pop("type", d.pop("type_", UNSET))
-
-        store_configuration = cls(
-            available_models=available_models,
-            description=description,
-            display_name=display_name,
-            if_=if_,
-            name=name,
-            options=options,
-            required=required,
-            secret=secret,
-            type_=type_,
-        )
-
-        store_configuration.additional_properties = d
-        return store_configuration
-
-    @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

blaxel/core/client/models/store_configuration_option.py

@@ -1,79 +0,0 @@
-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="StoreConfigurationOption")
-
-
-@_attrs_define
-class StoreConfigurationOption:
-    """Store configuration options for a select type configuration
-
-    Attributes:
-        if_ (Union[Unset, str]): Conditional rendering for the configuration option, example: provider === 'openai'
-        label (Union[Unset, str]): Store configuration option label
-        value (Union[Unset, str]): Store configuration option value
-    """
-
-    if_: Union[Unset, str] = UNSET
-    label: Union[Unset, str] = UNSET
-    value: Union[Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        if_ = self.if_
-
-        label = self.label
-
-        value = self.value
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if if_ is not UNSET:
-            field_dict["if"] = if_
-        if label is not UNSET:
-            field_dict["label"] = label
-        if value is not UNSET:
-            field_dict["value"] = value
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        if_ = d.pop("if", d.pop("if_", UNSET))
-
-        label = d.pop("label", UNSET)
-
-        value = d.pop("value", UNSET)
-
-        store_configuration_option = cls(
-            if_=if_,
-            label=label,
-            value=value,
-        )
-
-        store_configuration_option.additional_properties = d
-        return store_configuration_option
-
-    @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

blaxel/core/client/models/time_to_first_token_over_time_metrics.py

@@ -1,87 +0,0 @@
-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.request_duration_over_time_metric import RequestDurationOverTimeMetric
-
-
-T = TypeVar("T", bound="TimeToFirstTokenOverTimeMetrics")
-
-
-@_attrs_define
-class TimeToFirstTokenOverTimeMetrics:
-    """Time to first token over time metrics
-
-    Attributes:
-        time_to_first_token_over_time (Union[Unset, list['RequestDurationOverTimeMetric']]): Time to first token over
-            time
-    """
-
-    time_to_first_token_over_time: Union[Unset, list["RequestDurationOverTimeMetric"]] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        time_to_first_token_over_time: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.time_to_first_token_over_time, Unset):
-            time_to_first_token_over_time = []
-            for time_to_first_token_over_time_item_data in self.time_to_first_token_over_time:
-                if type(time_to_first_token_over_time_item_data) is dict:
-                    time_to_first_token_over_time_item = time_to_first_token_over_time_item_data
-                else:
-                    time_to_first_token_over_time_item = (
-                        time_to_first_token_over_time_item_data.to_dict()
-                    )
-                time_to_first_token_over_time.append(time_to_first_token_over_time_item)
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if time_to_first_token_over_time is not UNSET:
-            field_dict["timeToFirstTokenOverTime"] = time_to_first_token_over_time
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.request_duration_over_time_metric import RequestDurationOverTimeMetric
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        time_to_first_token_over_time = []
-        _time_to_first_token_over_time = d.pop(
-            "timeToFirstTokenOverTime", d.pop("time_to_first_token_over_time", UNSET)
-        )
-        for time_to_first_token_over_time_item_data in _time_to_first_token_over_time or []:
-            time_to_first_token_over_time_item = RequestDurationOverTimeMetric.from_dict(
-                time_to_first_token_over_time_item_data
-            )
-
-            time_to_first_token_over_time.append(time_to_first_token_over_time_item)
-
-        time_to_first_token_over_time_metrics = cls(
-            time_to_first_token_over_time=time_to_first_token_over_time,
-        )
-
-        time_to_first_token_over_time_metrics.additional_properties = d
-        return time_to_first_token_over_time_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

blaxel/core/client/models/token_rate_metric.py

@@ -1,106 +0,0 @@
-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="TokenRateMetric")
-
-
-@_attrs_define
-class TokenRateMetric:
-    """Token rate metric
-
-    Attributes:
-        model (Union[Unset, str]): Model ID
-        provider (Union[Unset, str]): Provider name
-        provider_name (Union[Unset, str]): Provider integration name
-        timestamp (Union[Unset, str]): Timestamp
-        token_total (Union[Unset, float]): Total tokens
-        trend (Union[Unset, float]): Trend
-    """
-
-    model: Union[Unset, str] = UNSET
-    provider: Union[Unset, str] = UNSET
-    provider_name: Union[Unset, str] = UNSET
-    timestamp: Union[Unset, str] = UNSET
-    token_total: Union[Unset, float] = UNSET
-    trend: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        model = self.model
-
-        provider = self.provider
-
-        provider_name = self.provider_name
-
-        timestamp = self.timestamp
-
-        token_total = self.token_total
-
-        trend = self.trend
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if model is not UNSET:
-            field_dict["model"] = model
-        if provider is not UNSET:
-            field_dict["provider"] = provider
-        if provider_name is not UNSET:
-            field_dict["providerName"] = provider_name
-        if timestamp is not UNSET:
-            field_dict["timestamp"] = timestamp
-        if token_total is not UNSET:
-            field_dict["tokenTotal"] = token_total
-        if trend is not UNSET:
-            field_dict["trend"] = trend
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        model = d.pop("model", UNSET)
-
-        provider = d.pop("provider", UNSET)
-
-        provider_name = d.pop("providerName", d.pop("provider_name", UNSET))
-
-        timestamp = d.pop("timestamp", UNSET)
-
-        token_total = d.pop("tokenTotal", d.pop("token_total", UNSET))
-
-        trend = d.pop("trend", UNSET)
-
-        token_rate_metric = cls(
-            model=model,
-            provider=provider,
-            provider_name=provider_name,
-            timestamp=timestamp,
-            token_total=token_total,
-            trend=trend,
-        )
-
-        token_rate_metric.additional_properties = d
-        return token_rate_metric
-
-    @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

blaxel/core/client/models/token_rate_metrics.py

@@ -1,124 +0,0 @@
-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.token_rate_metric import TokenRateMetric
-
-
-T = TypeVar("T", bound="TokenRateMetrics")
-
-
-@_attrs_define
-class TokenRateMetrics:
-    """Token rate metrics
-
-    Attributes:
-        token_rate (Union[Unset, list['TokenRateMetric']]): Token rate
-        token_rate_input (Union[Unset, list['TokenRateMetric']]): Token rate input
-        token_rate_output (Union[Unset, list['TokenRateMetric']]): Token rate output
-    """
-
-    token_rate: Union[Unset, list["TokenRateMetric"]] = UNSET
-    token_rate_input: Union[Unset, list["TokenRateMetric"]] = UNSET
-    token_rate_output: Union[Unset, list["TokenRateMetric"]] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        token_rate: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.token_rate, Unset):
-            token_rate = []
-            for token_rate_item_data in self.token_rate:
-                if type(token_rate_item_data) is dict:
-                    token_rate_item = token_rate_item_data
-                else:
-                    token_rate_item = token_rate_item_data.to_dict()
-                token_rate.append(token_rate_item)
-
-        token_rate_input: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.token_rate_input, Unset):
-            token_rate_input = []
-            for token_rate_input_item_data in self.token_rate_input:
-                if type(token_rate_input_item_data) is dict:
-                    token_rate_input_item = token_rate_input_item_data
-                else:
-                    token_rate_input_item = token_rate_input_item_data.to_dict()
-                token_rate_input.append(token_rate_input_item)
-
-        token_rate_output: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.token_rate_output, Unset):
-            token_rate_output = []
-            for token_rate_output_item_data in self.token_rate_output:
-                if type(token_rate_output_item_data) is dict:
-                    token_rate_output_item = token_rate_output_item_data
-                else:
-                    token_rate_output_item = token_rate_output_item_data.to_dict()
-                token_rate_output.append(token_rate_output_item)
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if token_rate is not UNSET:
-            field_dict["tokenRate"] = token_rate
-        if token_rate_input is not UNSET:
-            field_dict["tokenRateInput"] = token_rate_input
-        if token_rate_output is not UNSET:
-            field_dict["tokenRateOutput"] = token_rate_output
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.token_rate_metric import TokenRateMetric
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        token_rate = []
-        _token_rate = d.pop("tokenRate", d.pop("token_rate", UNSET))
-        for token_rate_item_data in _token_rate or []:
-            token_rate_item = TokenRateMetric.from_dict(token_rate_item_data)
-
-            token_rate.append(token_rate_item)
-
-        token_rate_input = []
-        _token_rate_input = d.pop("tokenRateInput", d.pop("token_rate_input", UNSET))
-        for token_rate_input_item_data in _token_rate_input or []:
-            token_rate_input_item = TokenRateMetric.from_dict(token_rate_input_item_data)
-
-            token_rate_input.append(token_rate_input_item)
-
-        token_rate_output = []
-        _token_rate_output = d.pop("tokenRateOutput", d.pop("token_rate_output", UNSET))
-        for token_rate_output_item_data in _token_rate_output or []:
-            token_rate_output_item = TokenRateMetric.from_dict(token_rate_output_item_data)
-
-            token_rate_output.append(token_rate_output_item)
-
-        token_rate_metrics = cls(
-            token_rate=token_rate,
-            token_rate_input=token_rate_input,
-            token_rate_output=token_rate_output,
-        )
-
-        token_rate_metrics.additional_properties = d
-        return token_rate_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

blaxel/core/client/models/token_total_metric.py

@@ -1,112 +0,0 @@
-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="TokenTotalMetric")
-
-
-@_attrs_define
-class TokenTotalMetric:
-    """Token total metric
-
-    Attributes:
-        average_token_input_per_request (Union[Unset, float]): Average input token per request
-        average_token_output_per_request (Union[Unset, float]): Average output token per request
-        average_token_per_request (Union[Unset, float]): Average token per request
-        token_input (Union[Unset, float]): Total input tokens
-        token_output (Union[Unset, float]): Total output tokens
-        token_total (Union[Unset, float]): Total tokens
-    """
-
-    average_token_input_per_request: Union[Unset, float] = UNSET
-    average_token_output_per_request: Union[Unset, float] = UNSET
-    average_token_per_request: Union[Unset, float] = UNSET
-    token_input: Union[Unset, float] = UNSET
-    token_output: Union[Unset, float] = UNSET
-    token_total: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        average_token_input_per_request = self.average_token_input_per_request
-
-        average_token_output_per_request = self.average_token_output_per_request
-
-        average_token_per_request = self.average_token_per_request
-
-        token_input = self.token_input
-
-        token_output = self.token_output
-
-        token_total = self.token_total
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if average_token_input_per_request is not UNSET:
-            field_dict["averageTokenInputPerRequest"] = average_token_input_per_request
-        if average_token_output_per_request is not UNSET:
-            field_dict["averageTokenOutputPerRequest"] = average_token_output_per_request
-        if average_token_per_request is not UNSET:
-            field_dict["averageTokenPerRequest"] = average_token_per_request
-        if token_input is not UNSET:
-            field_dict["tokenInput"] = token_input
-        if token_output is not UNSET:
-            field_dict["tokenOutput"] = token_output
-        if token_total is not UNSET:
-            field_dict["tokenTotal"] = token_total
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        average_token_input_per_request = d.pop(
-            "averageTokenInputPerRequest", d.pop("average_token_input_per_request", UNSET)
-        )
-
-        average_token_output_per_request = d.pop(
-            "averageTokenOutputPerRequest", d.pop("average_token_output_per_request", UNSET)
-        )
-
-        average_token_per_request = d.pop(
-            "averageTokenPerRequest", d.pop("average_token_per_request", UNSET)
-        )
-
-        token_input = d.pop("tokenInput", d.pop("token_input", UNSET))
-
-        token_output = d.pop("tokenOutput", d.pop("token_output", UNSET))
-
-        token_total = d.pop("tokenTotal", d.pop("token_total", UNSET))
-
-        token_total_metric = cls(
-            average_token_input_per_request=average_token_input_per_request,
-            average_token_output_per_request=average_token_output_per_request,
-            average_token_per_request=average_token_per_request,
-            token_input=token_input,
-            token_output=token_output,
-            token_total=token_total,
-        )
-
-        token_total_metric.additional_properties = d
-        return token_total_metric
-
-    @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