blaxel 0.1.21__py3-none-any.whl → 0.1.22rc70__py3-none-any.whl

blaxel/agents/__init__.py

@@ -6,7 +6,7 @@ from ..cache import find_from_cache
 from ..client import client
 from ..client.api.agents import get_agent
 from ..client.models import Agent
-from ..common.internal import get_global_unique_hash, get_forced_url
+from ..common.internal import get_forced_url, get_global_unique_hash
 from ..common.settings import settings
 from ..instrumentation.span import SpanManager
 

blaxel/client/models/__init__.py

@@ -4,6 +4,7 @@ from .acl import ACL
 from .agent import Agent
 from .agent_spec import AgentSpec
 from .api_key import ApiKey
+from .billable_time_metric import BillableTimeMetric
 from .check_workspace_availability_body import CheckWorkspaceAvailabilityBody
 from .configuration import Configuration
 from .continent import Continent
@@ -71,9 +72,12 @@ from .knowledgebase_spec_options import KnowledgebaseSpecOptions
 from .last_n_requests_metric import LastNRequestsMetric
 from .latency_metric import LatencyMetric
 from .location_response import LocationResponse
+from .logs_response import LogsResponse
+from .logs_response_data import LogsResponseData
 from .mcp_definition import MCPDefinition
 from .mcp_definition_entrypoint import MCPDefinitionEntrypoint
 from .mcp_definition_form import MCPDefinitionForm
+from .memory_allocation_by_name import MemoryAllocationByName
 from .memory_allocation_metric import MemoryAllocationMetric
 from .metadata import Metadata
 from .metadata_labels import MetadataLabels
@@ -123,7 +127,10 @@ from .request_total_metric import RequestTotalMetric
 from .request_total_metric_request_total_per_code import RequestTotalMetricRequestTotalPerCode
 from .request_total_metric_rps_per_code import RequestTotalMetricRpsPerCode
 from .request_total_response_data import RequestTotalResponseData
+from .resource import Resource
 from .resource_log import ResourceLog
+from .resource_log_chart import ResourceLogChart
+from .resource_log_response import ResourceLogResponse
 from .resource_metrics import ResourceMetrics
 from .resource_metrics_request_total_per_code import ResourceMetricsRequestTotalPerCode
 from .resource_metrics_request_total_per_code_previous import (
@@ -131,6 +138,7 @@ from .resource_metrics_request_total_per_code_previous import (
 )
 from .resource_metrics_rps_per_code import ResourceMetricsRpsPerCode
 from .resource_metrics_rps_per_code_previous import ResourceMetricsRpsPerCodePrevious
+from .resource_trace import ResourceTrace
 from .revision_configuration import RevisionConfiguration
 from .revision_metadata import RevisionMetadata
 from .runtime import Runtime
@@ -162,6 +170,7 @@ from .update_workspace_service_account_body import UpdateWorkspaceServiceAccount
 from .update_workspace_service_account_response_200 import UpdateWorkspaceServiceAccountResponse200
 from .update_workspace_user_role_body import UpdateWorkspaceUserRoleBody
 from .websocket_channel import WebsocketChannel
+from .websocket_message import WebsocketMessage
 from .workspace import Workspace
 from .workspace_labels import WorkspaceLabels
 from .workspace_runtime import WorkspaceRuntime
@@ -172,6 +181,7 @@ __all__ = (
     "Agent",
     "AgentSpec",
     "ApiKey",
+    "BillableTimeMetric",
     "CheckWorkspaceAvailabilityBody",
     "Configuration",
     "Continent",
@@ -237,9 +247,12 @@ __all__ = (
     "LastNRequestsMetric",
     "LatencyMetric",
     "LocationResponse",
+    "LogsResponse",
+    "LogsResponseData",
     "MCPDefinition",
     "MCPDefinitionEntrypoint",
     "MCPDefinitionForm",
+    "MemoryAllocationByName",
     "MemoryAllocationMetric",
     "Metadata",
     "MetadataLabels",
@@ -285,12 +298,16 @@ __all__ = (
     "RequestTotalMetricRequestTotalPerCode",
     "RequestTotalMetricRpsPerCode",
     "RequestTotalResponseData",
+    "Resource",
     "ResourceLog",
+    "ResourceLogChart",
+    "ResourceLogResponse",
     "ResourceMetrics",
     "ResourceMetricsRequestTotalPerCode",
     "ResourceMetricsRequestTotalPerCodePrevious",
     "ResourceMetricsRpsPerCode",
     "ResourceMetricsRpsPerCodePrevious",
+    "ResourceTrace",
     "RevisionConfiguration",
     "RevisionMetadata",
     "Runtime",
@@ -322,6 +339,7 @@ __all__ = (
     "UpdateWorkspaceServiceAccountResponse200",
     "UpdateWorkspaceUserRoleBody",
     "WebsocketChannel",
+    "WebsocketMessage",
     "Workspace",
     "WorkspaceLabels",
     "WorkspaceRuntime",

blaxel/client/models/billable_time_metric.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="BillableTimeMetric")
+
+
+@_attrs_define
+class BillableTimeMetric:
+    """Billable time metric
+
+    Attributes:
+        billable_time (Union[Unset, float]): Billable time
+        total_allocation (Union[Unset, float]): Total memory allocation in GB-seconds
+    """
+
+    billable_time: Union[Unset, float] = UNSET
+    total_allocation: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        billable_time = self.billable_time
+
+        total_allocation = self.total_allocation
+
+        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 total_allocation is not UNSET:
+            field_dict["totalAllocation"] = total_allocation
+
+        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()
+        billable_time = d.pop("billableTime", UNSET)
+
+        total_allocation = d.pop("totalAllocation", UNSET)
+
+        billable_time_metric = cls(
+            billable_time=billable_time,
+            total_allocation=total_allocation,
+        )
+
+        billable_time_metric.additional_properties = d
+        return billable_time_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/client/models/jobs_chart_value.py

@@ -14,11 +14,11 @@ class JobsChartValue:
 
     Attributes:
         timestamp (Union[Unset, str]): Metric timestamp
-        value (Union[Unset, int]): Metric value
+        value (Union[Unset, float]): Metric value
     """
 
     timestamp: Union[Unset, str] = UNSET
-    value: Union[Unset, int] = UNSET
+    value: Union[Unset, float] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:

blaxel/{sandbox/client/models/process_kill_request.py → client/models/logs_response.py}

@@ -1,31 +1,34 @@
-from typing import Any, TypeVar, Union
+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="ProcessKillRequest")
+T = TypeVar("T", bound="LogsResponse")
 
 
 @_attrs_define
-class ProcessKillRequest:
-    """
+class LogsResponse:
+    """Response for logs
+
     Attributes:
-        signal (Union[Unset, str]):  Example: SIGTERM.
+        data (Union[Unset, list[Any]]): Data
     """
 
-    signal: Union[Unset, str] = UNSET
+    data: Union[Unset, list[Any]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        signal = self.signal
+        data: Union[Unset, list[Any]] = UNSET
+        if not isinstance(self.data, Unset):
+            data = self.data
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
-        if signal is not UNSET:
-            field_dict["signal"] = signal
+        if data is not UNSET:
+            field_dict["data"] = data
 
         return field_dict
 
@@ -34,14 +37,14 @@ class ProcessKillRequest:
         if not src_dict:
             return None
         d = src_dict.copy()
-        signal = d.pop("signal", UNSET)
+        data = cast(list[Any], d.pop("data", UNSET))
 
-        process_kill_request = cls(
-            signal=signal,
+        logs_response = cls(
+            data=data,
         )
 
-        process_kill_request.additional_properties = d
-        return process_kill_request
+        logs_response.additional_properties = d
+        return logs_response
 
     @property
     def additional_keys(self) -> list[str]:

blaxel/client/models/logs_response_data.py

@@ -0,0 +1,99 @@
+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="LogsResponseData")
+
+
+@_attrs_define
+class LogsResponseData:
+    """Response data for logs
+
+    Attributes:
+        body (Union[Unset, str]): Body of the log
+        log_attributes (Union[Unset, list[Any]]): Log attributes
+        severity_number (Union[Unset, int]): Severity number of the log
+        timestamp (Union[Unset, str]): Timestamp of the log
+        trace_id (Union[Unset, str]): Trace ID of the log
+    """
+
+    body: Union[Unset, str] = UNSET
+    log_attributes: Union[Unset, list[Any]] = UNSET
+    severity_number: Union[Unset, int] = UNSET
+    timestamp: Union[Unset, str] = 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]:
+        body = self.body
+
+        log_attributes: Union[Unset, list[Any]] = UNSET
+        if not isinstance(self.log_attributes, Unset):
+            log_attributes = self.log_attributes
+
+        severity_number = self.severity_number
+
+        timestamp = self.timestamp
+
+        trace_id = self.trace_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if body is not UNSET:
+            field_dict["body"] = body
+        if log_attributes is not UNSET:
+            field_dict["logAttributes"] = log_attributes
+        if severity_number is not UNSET:
+            field_dict["severityNumber"] = severity_number
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        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()
+        body = d.pop("body", UNSET)
+
+        log_attributes = cast(list[Any], d.pop("logAttributes", UNSET))
+
+        severity_number = d.pop("severityNumber", UNSET)
+
+        timestamp = d.pop("timestamp", UNSET)
+
+        trace_id = d.pop("traceId", UNSET)
+
+        logs_response_data = cls(
+            body=body,
+            log_attributes=log_attributes,
+            severity_number=severity_number,
+            timestamp=timestamp,
+            trace_id=trace_id,
+        )
+
+        logs_response_data.additional_properties = d
+        return logs_response_data
+
+    @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/models/memory_allocation_by_name.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="MemoryAllocationByName")
+
+
+@_attrs_define
+class MemoryAllocationByName:
+    """Memory allocation by service name
+
+    Attributes:
+        allocation (Union[Unset, float]): Memory allocation value
+        name (Union[Unset, str]): Name
+    """
+
+    allocation: Union[Unset, float] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        allocation = self.allocation
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if allocation is not UNSET:
+            field_dict["allocation"] = allocation
+        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()
+        allocation = d.pop("allocation", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        memory_allocation_by_name = cls(
+            allocation=allocation,
+            name=name,
+        )
+
+        memory_allocation_by_name.additional_properties = d
+        return memory_allocation_by_name
+
+    @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/models/metadata.py

@@ -24,6 +24,7 @@ class Metadata:
         display_name (Union[Unset, str]): Model display name
         labels (Union[Unset, MetadataLabels]): Labels
         name (Union[Unset, str]): Model name
+        plan (Union[Unset, Any]): Plan
         workspace (Union[Unset, str]): Workspace name
     """
 
@@ -34,6 +35,7 @@ class Metadata:
     display_name: Union[Unset, str] = UNSET
     labels: Union[Unset, "MetadataLabels"] = UNSET
     name: Union[Unset, str] = UNSET
+    plan: Union[Unset, Any] = UNSET
     workspace: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -56,6 +58,8 @@ class Metadata:
 
         name = self.name
 
+        plan = self.plan
+
         workspace = self.workspace
 
         field_dict: dict[str, Any] = {}
@@ -75,6 +79,8 @@ class Metadata:
             field_dict["labels"] = labels
         if name is not UNSET:
             field_dict["name"] = name
+        if plan is not UNSET:
+            field_dict["plan"] = plan
         if workspace is not UNSET:
             field_dict["workspace"] = workspace
 
@@ -106,6 +112,8 @@ class Metadata:
 
         name = d.pop("name", UNSET)
 
+        plan = d.pop("plan", UNSET)
+
         workspace = d.pop("workspace", UNSET)
 
         metadata = cls(
@@ -116,6 +124,7 @@ class Metadata:
             display_name=display_name,
             labels=labels,
             name=name,
+            plan=plan,
             workspace=workspace,
         )
 

blaxel/client/models/resource.py

@@ -0,0 +1,79 @@
+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="Resource")
+
+
+@_attrs_define
+class Resource:
+    """Resource
+
+    Attributes:
+        name (Union[Unset, str]): Name of the resource
+        type_ (Union[Unset, str]): Type of the resource
+        workspace (Union[Unset, str]): Workspace of the resource
+    """
+
+    name: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    workspace: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        type_ = self.type_
+
+        workspace = self.workspace
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        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()
+        name = d.pop("name", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        workspace = d.pop("workspace", UNSET)
+
+        resource = cls(
+            name=name,
+            type_=type_,
+            workspace=workspace,
+        )
+
+        resource.additional_properties = d
+        return resource
+
+    @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/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