blaxel 0.1.21rc69__py3-none-any.whl → 0.2.0__py3-none-any.whl

blaxel/core/client/models/resource_log_chart.py

@@ -0,0 +1,133 @@
+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="ResourceLogChart")
+
+
+@_attrs_define
+class ResourceLogChart:
+    """Chart for a resource log
+
+    Attributes:
+        count (Union[Unset, int]): Count of the log
+        debug (Union[Unset, int]): Debug count of the log
+        error (Union[Unset, int]): Error count of the log
+        fatal (Union[Unset, int]): Fatal count of the log
+        info (Union[Unset, int]): Info count of the log
+        timestamp (Union[Unset, str]): Timestamp of the log
+        trace (Union[Unset, int]): Trace count of the log
+        unknown (Union[Unset, int]): Unknown count of the log
+        warning (Union[Unset, int]): Warning count of the log
+    """
+
+    count: Union[Unset, int] = UNSET
+    debug: Union[Unset, int] = UNSET
+    error: Union[Unset, int] = UNSET
+    fatal: Union[Unset, int] = UNSET
+    info: Union[Unset, int] = UNSET
+    timestamp: Union[Unset, str] = UNSET
+    trace: Union[Unset, int] = UNSET
+    unknown: Union[Unset, int] = UNSET
+    warning: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        count = self.count
+
+        debug = self.debug
+
+        error = self.error
+
+        fatal = self.fatal
+
+        info = self.info
+
+        timestamp = self.timestamp
+
+        trace = self.trace
+
+        unknown = self.unknown
+
+        warning = self.warning
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if count is not UNSET:
+            field_dict["count"] = count
+        if debug is not UNSET:
+            field_dict["debug"] = debug
+        if error is not UNSET:
+            field_dict["error"] = error
+        if fatal is not UNSET:
+            field_dict["fatal"] = fatal
+        if info is not UNSET:
+            field_dict["info"] = info
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        if trace is not UNSET:
+            field_dict["trace"] = trace
+        if unknown is not UNSET:
+            field_dict["unknown"] = unknown
+        if warning is not UNSET:
+            field_dict["warning"] = warning
+
+        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()
+        count = d.pop("count", UNSET)
+
+        debug = d.pop("debug", UNSET)
+
+        error = d.pop("error", UNSET)
+
+        fatal = d.pop("fatal", UNSET)
+
+        info = d.pop("info", UNSET)
+
+        timestamp = d.pop("timestamp", UNSET)
+
+        trace = d.pop("trace", UNSET)
+
+        unknown = d.pop("unknown", UNSET)
+
+        warning = d.pop("warning", UNSET)
+
+        resource_log_chart = cls(
+            count=count,
+            debug=debug,
+            error=error,
+            fatal=fatal,
+            info=info,
+            timestamp=timestamp,
+            trace=trace,
+            unknown=unknown,
+            warning=warning,
+        )
+
+        resource_log_chart.additional_properties = d
+        return resource_log_chart
+
+    @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/resource_log_response.py

@@ -0,0 +1,83 @@
+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="ResourceLogResponse")
+
+
+@_attrs_define
+class ResourceLogResponse:
+    """Response for a resource log
+
+    Attributes:
+        chart (Union[Unset, list[Any]]): Chart
+        logs (Union[Unset, list[Any]]): Logs
+        total_count (Union[Unset, int]): Total count of logs
+    """
+
+    chart: Union[Unset, list[Any]] = UNSET
+    logs: Union[Unset, list[Any]] = UNSET
+    total_count: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        chart: Union[Unset, list[Any]] = UNSET
+        if not isinstance(self.chart, Unset):
+            chart = self.chart
+
+        logs: Union[Unset, list[Any]] = UNSET
+        if not isinstance(self.logs, Unset):
+            logs = self.logs
+
+        total_count = self.total_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if chart is not UNSET:
+            field_dict["chart"] = chart
+        if logs is not UNSET:
+            field_dict["logs"] = logs
+        if total_count is not UNSET:
+            field_dict["totalCount"] = total_count
+
+        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()
+        chart = cast(list[Any], d.pop("chart", UNSET))
+
+        logs = cast(list[Any], d.pop("logs", UNSET))
+
+        total_count = d.pop("totalCount", UNSET)
+
+        resource_log_response = cls(
+            chart=chart,
+            logs=logs,
+            total_count=total_count,
+        )
+
+        resource_log_response.additional_properties = d
+        return resource_log_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/{client → core/client}/models/resource_metrics.py

@@ -6,6 +6,7 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
+    from ..models.billable_time_metric import BillableTimeMetric
     from ..models.latency_metric import LatencyMetric
     from ..models.memory_allocation_metric import MemoryAllocationMetric
     from ..models.metric import Metric
@@ -30,6 +31,7 @@ class ResourceMetrics:
     """Metrics for a single resource deployment (eg. model deployment, function deployment)
 
     Attributes:
+        billable_time (Union[Unset, BillableTimeMetric]): Billable time metric
         inference_errors_global (Union[Unset, list['Metric']]): Array of metrics
         inference_global (Union[Unset, list['Metric']]): Array of metrics
         last_n_requests (Union[Unset, list['Metric']]): Array of metrics
@@ -59,6 +61,7 @@ class ResourceMetrics:
         token_total (Union[Unset, TokenTotalMetric]): Token total metric
     """
 
+    billable_time: Union[Unset, "BillableTimeMetric"] = UNSET
     inference_errors_global: Union[Unset, list["Metric"]] = UNSET
     inference_global: Union[Unset, list["Metric"]] = UNSET
     last_n_requests: Union[Unset, list["Metric"]] = UNSET
@@ -83,11 +86,21 @@ class ResourceMetrics:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        billable_time: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.billable_time
+            and not isinstance(self.billable_time, Unset)
+            and not isinstance(self.billable_time, dict)
+        ):
+            billable_time = self.billable_time.to_dict()
+        elif self.billable_time and isinstance(self.billable_time, dict):
+            billable_time = self.billable_time
+
         inference_errors_global: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.inference_errors_global, Unset):
             inference_errors_global = []
             for componentsschemas_array_metric_item_data in self.inference_errors_global:
-                if type(componentsschemas_array_metric_item_data) == dict:
+                if type(componentsschemas_array_metric_item_data) is dict:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data
                 else:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data.to_dict()
@@ -97,7 +110,7 @@ class ResourceMetrics:
         if not isinstance(self.inference_global, Unset):
             inference_global = []
             for componentsschemas_array_metric_item_data in self.inference_global:
-                if type(componentsschemas_array_metric_item_data) == dict:
+                if type(componentsschemas_array_metric_item_data) is dict:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data
                 else:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data.to_dict()
@@ -107,7 +120,7 @@ class ResourceMetrics:
         if not isinstance(self.last_n_requests, Unset):
             last_n_requests = []
             for componentsschemas_array_metric_item_data in self.last_n_requests:
-                if type(componentsschemas_array_metric_item_data) == dict:
+                if type(componentsschemas_array_metric_item_data) is dict:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data
                 else:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data.to_dict()
@@ -244,6 +257,8 @@ class ResourceMetrics:
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
+        if billable_time is not UNSET:
+            field_dict["billableTime"] = billable_time
         if inference_errors_global is not UNSET:
             field_dict["inferenceErrorsGlobal"] = inference_errors_global
         if inference_global is not UNSET:
@@ -291,6 +306,7 @@ class ResourceMetrics:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.billable_time_metric import BillableTimeMetric
         from ..models.latency_metric import LatencyMetric
         from ..models.memory_allocation_metric import MemoryAllocationMetric
         from ..models.metric import Metric
@@ -313,6 +329,13 @@ class ResourceMetrics:
         if not src_dict:
             return None
         d = src_dict.copy()
+        _billable_time = d.pop("billableTime", UNSET)
+        billable_time: Union[Unset, BillableTimeMetric]
+        if isinstance(_billable_time, Unset):
+            billable_time = UNSET
+        else:
+            billable_time = BillableTimeMetric.from_dict(_billable_time)
+
         inference_errors_global = []
         _inference_errors_global = d.pop("inferenceErrorsGlobal", UNSET)
         for componentsschemas_array_metric_item_data in _inference_errors_global or []:
@@ -443,6 +466,7 @@ class ResourceMetrics:
             token_total = TokenTotalMetric.from_dict(_token_total)
 
         resource_metrics = cls(
+            billable_time=billable_time,
             inference_errors_global=inference_errors_global,
             inference_global=inference_global,
             last_n_requests=last_n_requests,

blaxel/core/client/models/resource_trace.py

@@ -0,0 +1,97 @@
+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="ResourceTrace")
+
+
+@_attrs_define
+class ResourceTrace:
+    """Log for a resource deployment (eg. model deployment, function deployment)
+
+    Attributes:
+        duration (Union[Unset, int]): Duration in nanoseconds
+        has_error (Union[Unset, bool]): Has error
+        start_time (Union[Unset, str]): The timestamp of the log
+        status_code (Union[Unset, int]): Status code
+        trace_id (Union[Unset, str]): Trace ID of the log
+    """
+
+    duration: Union[Unset, int] = UNSET
+    has_error: Union[Unset, bool] = UNSET
+    start_time: Union[Unset, str] = UNSET
+    status_code: Union[Unset, int] = UNSET
+    trace_id: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        duration = self.duration
+
+        has_error = self.has_error
+
+        start_time = self.start_time
+
+        status_code = self.status_code
+
+        trace_id = self.trace_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if duration is not UNSET:
+            field_dict["duration"] = duration
+        if has_error is not UNSET:
+            field_dict["hasError"] = has_error
+        if start_time is not UNSET:
+            field_dict["startTime"] = start_time
+        if status_code is not UNSET:
+            field_dict["statusCode"] = status_code
+        if trace_id is not UNSET:
+            field_dict["traceID"] = trace_id
+
+        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()
+        duration = d.pop("duration", UNSET)
+
+        has_error = d.pop("hasError", UNSET)
+
+        start_time = d.pop("startTime", UNSET)
+
+        status_code = d.pop("statusCode", UNSET)
+
+        trace_id = d.pop("traceID", UNSET)
+
+        resource_trace = cls(
+            duration=duration,
+            has_error=has_error,
+            start_time=start_time,
+            status_code=status_code,
+            trace_id=trace_id,
+        )
+
+        resource_trace.additional_properties = d
+        return resource_trace
+
+    @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/{client → core/client}/models/runtime.py

@@ -117,7 +117,7 @@ class Runtime:
         if not isinstance(self.ports, Unset):
             ports = []
             for componentsschemas_ports_item_data in self.ports:
-                if type(componentsschemas_ports_item_data) == dict:
+                if type(componentsschemas_ports_item_data) is dict:
                     componentsschemas_ports_item = componentsschemas_ports_item_data
                 else:
                     componentsschemas_ports_item = componentsschemas_ports_item_data.to_dict()

blaxel/{client → core/client}/models/sandbox.py

@@ -36,7 +36,7 @@ class Sandbox:
         if not isinstance(self.events, Unset):
             events = []
             for componentsschemas_core_events_item_data in self.events:
-                if type(componentsschemas_core_events_item_data) == dict:
+                if type(componentsschemas_core_events_item_data) is dict:
                     componentsschemas_core_events_item = componentsschemas_core_events_item_data
                 else:
                     componentsschemas_core_events_item = componentsschemas_core_events_item_data.to_dict()

blaxel/{client → core/client}/models/sandbox_definition.py

@@ -72,7 +72,7 @@ class SandboxDefinition:
         if not isinstance(self.ports, Unset):
             ports = []
             for componentsschemas_ports_item_data in self.ports:
-                if type(componentsschemas_ports_item_data) == dict:
+                if type(componentsschemas_ports_item_data) is dict:
                     componentsschemas_ports_item = componentsschemas_ports_item_data
                 else:
                     componentsschemas_ports_item = componentsschemas_ports_item_data.to_dict()

blaxel/{client → core/client}/models/sandbox_spec.py

@@ -60,7 +60,7 @@ class SandboxSpec:
         if not isinstance(self.flavors, Unset):
             flavors = []
             for componentsschemas_flavors_item_data in self.flavors:
-                if type(componentsschemas_flavors_item_data) == dict:
+                if type(componentsschemas_flavors_item_data) is dict:
                     componentsschemas_flavors_item = componentsschemas_flavors_item_data
                 else:
                     componentsschemas_flavors_item = componentsschemas_flavors_item_data.to_dict()

blaxel/{client → core/client}/models/store_agent.py

@@ -57,7 +57,7 @@ class StoreAgent:
         if not isinstance(self.configuration, Unset):
             configuration = []
             for configuration_item_data in self.configuration:
-                if type(configuration_item_data) == dict:
+                if type(configuration_item_data) is dict:
                     configuration_item = configuration_item_data
                 else:
                     configuration_item = configuration_item_data.to_dict()

blaxel/{client → core/client}/models/store_configuration.py

@@ -56,7 +56,7 @@ class StoreConfiguration:
         if not isinstance(self.options, Unset):
             options = []
             for options_item_data in self.options:
-                if type(options_item_data) == dict:
+                if type(options_item_data) is dict:
                     options_item = options_item_data
                 else:
                     options_item = options_item_data.to_dict()

blaxel/{client → core/client}/models/template.py

@@ -74,7 +74,7 @@ class Template:
         if not isinstance(self.variables, Unset):
             variables = []
             for variables_item_data in self.variables:
-                if type(variables_item_data) == dict:
+                if type(variables_item_data) is dict:
                     variables_item = variables_item_data
                 else:
                     variables_item = variables_item_data.to_dict()

blaxel/core/client/models/websocket_message.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="WebsocketMessage")
+
+
+@_attrs_define
+class WebsocketMessage:
+    """WebSocket connection details
+
+    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
+        id (Union[Unset, str]): Unique message ID
+        message (Union[Unset, str]): Message
+        ttl (Union[Unset, int]): TTL timestamp for automatic deletion
+        workspace (Union[Unset, str]): Workspace the connection belongs to
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    id: Union[Unset, str] = UNSET
+    message: Union[Unset, str] = UNSET
+    ttl: Union[Unset, int] = UNSET
+    workspace: 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
+
+        id = self.id
+
+        message = self.message
+
+        ttl = self.ttl
+
+        workspace = self.workspace
+
+        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
+        if id is not UNSET:
+            field_dict["id"] = id
+        if message is not UNSET:
+            field_dict["message"] = message
+        if ttl is not UNSET:
+            field_dict["ttl"] = ttl
+        if workspace is not UNSET:
+            field_dict["workspace"] = workspace
+
+        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)
+
+        id = d.pop("id", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        ttl = d.pop("ttl", UNSET)
+
+        workspace = d.pop("workspace", UNSET)
+
+        websocket_message = cls(
+            created_at=created_at,
+            updated_at=updated_at,
+            id=id,
+            message=message,
+            ttl=ttl,
+            workspace=workspace,
+        )
+
+        websocket_message.additional_properties = d
+        return websocket_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

blaxel/core/common/__init__.py

@@ -0,0 +1,6 @@
+from .autoload import autoload
+from .env import env
+from .internal import get_alphanumeric_limited_hash, get_global_unique_hash
+from .settings import Settings, settings
+
+__all__ = ["autoload", "Settings", "settings", "env", "get_alphanumeric_limited_hash", "get_global_unique_hash"]

blaxel/core/common/autoload.py

@@ -0,0 +1,21 @@
+import logging
+
+from ..client import client
+from .settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+def telemetry() -> None:
+    from blaxel.telemetry import telemetry_manager
+
+    telemetry_manager.initialize(settings)
+
+
+def autoload() -> None:
+    client.with_base_url(settings.base_url)
+    client.with_auth(settings.auth)
+    try:
+        telemetry()
+    except Exception:
+        pass