blaxel 0.64.0__py3-none-any.whl

blaxel/models/time_fields.py

@@ -0,0 +1,70 @@
+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="TimeFields")
+
+
+@_attrs_define
+class TimeFields:
+    """Time fields for Persistance
+
+    Attributes:
+        created_at (Union[Unset, str]): The date and time when the resource was created
+        updated_at (Union[Unset, str]): The date and time when the resource was updated
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if created_at is not UNSET:
+            field_dict["createdAt"] = created_at
+        if updated_at is not UNSET:
+            field_dict["updatedAt"] = updated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        created_at = d.pop("createdAt", UNSET)
+
+        updated_at = d.pop("updatedAt", UNSET)
+
+        time_fields = cls(
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        time_fields.additional_properties = d
+        return time_fields
+
+    @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/models/token_rate_metric.py

@@ -0,0 +1,88 @@
+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
+        timestamp (Union[Unset, str]): Timestamp
+        token_total (Union[Unset, float]): Total tokens
+        trend (Union[Unset, float]): Trend
+    """
+
+    model: 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
+
+        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 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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        model = d.pop("model", UNSET)
+
+        timestamp = d.pop("timestamp", UNSET)
+
+        token_total = d.pop("tokenTotal", UNSET)
+
+        trend = d.pop("trend", UNSET)
+
+        token_rate_metric = cls(
+            model=model,
+            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/models/token_rate_metrics.py

@@ -0,0 +1,120 @@
+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, TokenRateMetric]): Token rate metric
+        token_rate_input (Union[Unset, TokenRateMetric]): Token rate metric
+        token_rate_output (Union[Unset, TokenRateMetric]): Token rate metric
+    """
+
+    token_rate: Union[Unset, "TokenRateMetric"] = UNSET
+    token_rate_input: Union[Unset, "TokenRateMetric"] = UNSET
+    token_rate_output: Union[Unset, "TokenRateMetric"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        token_rate: Union[Unset, dict[str, Any]] = UNSET
+        if self.token_rate and not isinstance(self.token_rate, Unset) and not isinstance(self.token_rate, dict):
+            token_rate = self.token_rate.to_dict()
+        elif self.token_rate and isinstance(self.token_rate, dict):
+            token_rate = self.token_rate
+
+        token_rate_input: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.token_rate_input
+            and not isinstance(self.token_rate_input, Unset)
+            and not isinstance(self.token_rate_input, dict)
+        ):
+            token_rate_input = self.token_rate_input.to_dict()
+        elif self.token_rate_input and isinstance(self.token_rate_input, dict):
+            token_rate_input = self.token_rate_input
+
+        token_rate_output: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.token_rate_output
+            and not isinstance(self.token_rate_output, Unset)
+            and not isinstance(self.token_rate_output, dict)
+        ):
+            token_rate_output = self.token_rate_output.to_dict()
+        elif self.token_rate_output and isinstance(self.token_rate_output, dict):
+            token_rate_output = self.token_rate_output
+
+        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:
+        from ..models.token_rate_metric import TokenRateMetric
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        _token_rate = d.pop("tokenRate", UNSET)
+        token_rate: Union[Unset, TokenRateMetric]
+        if isinstance(_token_rate, Unset):
+            token_rate = UNSET
+        else:
+            token_rate = TokenRateMetric.from_dict(_token_rate)
+
+        _token_rate_input = d.pop("tokenRateInput", UNSET)
+        token_rate_input: Union[Unset, TokenRateMetric]
+        if isinstance(_token_rate_input, Unset):
+            token_rate_input = UNSET
+        else:
+            token_rate_input = TokenRateMetric.from_dict(_token_rate_input)
+
+        _token_rate_output = d.pop("tokenRateOutput", UNSET)
+        token_rate_output: Union[Unset, TokenRateMetric]
+        if isinstance(_token_rate_output, Unset):
+            token_rate_output = UNSET
+        else:
+            token_rate_output = TokenRateMetric.from_dict(_token_rate_output)
+
+        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/models/token_total_metric.py

@@ -0,0 +1,106 @@
+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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        average_token_input_per_request = d.pop("averageTokenInputPerRequest", UNSET)
+
+        average_token_output_per_request = d.pop("averageTokenOutputPerRequest", UNSET)
+
+        average_token_per_request = d.pop("averageTokenPerRequest", UNSET)
+
+        token_input = d.pop("tokenInput", UNSET)
+
+        token_output = d.pop("tokenOutput", UNSET)
+
+        token_total = d.pop("tokenTotal", 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

blaxel/models/trace_ids_response.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="TraceIdsResponse")
+
+
+@_attrs_define
+class TraceIdsResponse:
+    """Trace IDs response"""
+
+    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: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        trace_ids_response = cls()
+
+        trace_ids_response.additional_properties = d
+        return trace_ids_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

blaxel/models/update_workspace_service_account_body.py

@@ -0,0 +1,69 @@
+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="UpdateWorkspaceServiceAccountBody")
+
+
+@_attrs_define
+class UpdateWorkspaceServiceAccountBody:
+    """
+    Attributes:
+        description (Union[Unset, str]): Service account description
+        name (Union[Unset, str]): Service account name
+    """
+
+    description: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        description = self.description
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if description is not UNSET:
+            field_dict["description"] = description
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        description = d.pop("description", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        update_workspace_service_account_body = cls(
+            description=description,
+            name=name,
+        )
+
+        update_workspace_service_account_body.additional_properties = d
+        return update_workspace_service_account_body
+
+    @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/models/update_workspace_service_account_response_200.py

@@ -0,0 +1,96 @@
+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="UpdateWorkspaceServiceAccountResponse200")
+
+
+@_attrs_define
+class UpdateWorkspaceServiceAccountResponse200:
+    """
+    Attributes:
+        client_id (Union[Unset, str]): Service account client ID
+        created_at (Union[Unset, str]): Creation timestamp
+        description (Union[Unset, str]): Service account description
+        name (Union[Unset, str]): Service account name
+        updated_at (Union[Unset, str]): Last update timestamp
+    """
+
+    client_id: Union[Unset, str] = UNSET
+    created_at: Union[Unset, str] = UNSET
+    description: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        client_id = self.client_id
+
+        created_at = self.created_at
+
+        description = self.description
+
+        name = self.name
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if description is not UNSET:
+            field_dict["description"] = description
+        if name is not UNSET:
+            field_dict["name"] = name
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        client_id = d.pop("client_id", UNSET)
+
+        created_at = d.pop("created_at", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        update_workspace_service_account_response_200 = cls(
+            client_id=client_id,
+            created_at=created_at,
+            description=description,
+            name=name,
+            updated_at=updated_at,
+        )
+
+        update_workspace_service_account_response_200.additional_properties = d
+        return update_workspace_service_account_response_200
+
+    @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/models/update_workspace_user_role_body.py

@@ -0,0 +1,60 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="UpdateWorkspaceUserRoleBody")
+
+
+@_attrs_define
+class UpdateWorkspaceUserRoleBody:
+    """
+    Attributes:
+        role (str): The new role to assign to the user
+    """
+
+    role: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        role = d.pop("role")
+
+        update_workspace_user_role_body = cls(
+            role=role,
+        )
+
+        update_workspace_user_role_body.additional_properties = d
+        return update_workspace_user_role_body
+
+    @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