blaxel 0.2.26rc119__py3-none-any.whl → 0.2.27__py3-none-any.whl

blaxel/core/client/models/resource_metrics.py

@@ -95,6 +95,7 @@ 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

blaxel/core/client/models/revision_configuration.py

@@ -16,12 +16,14 @@ class RevisionConfiguration:
         active (Union[Unset, str]): Active revision id
         canary (Union[Unset, str]): Canary revision id
         canary_percent (Union[Unset, int]): Canary revision percent
+        sticky_session_ttl (Union[Unset, int]): Sticky session TTL in seconds (0 = disabled)
         traffic (Union[Unset, int]): Traffic percentage
     """
 
     active: Union[Unset, str] = UNSET
     canary: Union[Unset, str] = UNSET
     canary_percent: Union[Unset, int] = UNSET
+    sticky_session_ttl: Union[Unset, int] = UNSET
     traffic: Union[Unset, int] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -32,6 +34,8 @@ class RevisionConfiguration:
 
         canary_percent = self.canary_percent
 
+        sticky_session_ttl = self.sticky_session_ttl
+
         traffic = self.traffic
 
         field_dict: dict[str, Any] = {}
@@ -43,6 +47,8 @@ class RevisionConfiguration:
             field_dict["canary"] = canary
         if canary_percent is not UNSET:
             field_dict["canaryPercent"] = canary_percent
+        if sticky_session_ttl is not UNSET:
+            field_dict["stickySessionTtl"] = sticky_session_ttl
         if traffic is not UNSET:
             field_dict["traffic"] = traffic
 
@@ -59,12 +65,15 @@ class RevisionConfiguration:
 
         canary_percent = d.pop("canaryPercent", UNSET)
 
+        sticky_session_ttl = d.pop("stickySessionTtl", UNSET)
+
         traffic = d.pop("traffic", UNSET)
 
         revision_configuration = cls(
             active=active,
             canary=canary,
             canary_percent=canary_percent,
+            sticky_session_ttl=sticky_session_ttl,
             traffic=traffic,
         )
 

blaxel/core/client/models/runtime.py

@@ -73,6 +73,7 @@ class Runtime:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         args: Union[Unset, list[Any]] = UNSET
         if not isinstance(self.args, Unset):
             args = self.args

blaxel/core/client/models/sandbox.py

@@ -36,6 +36,7 @@ class Sandbox:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         events: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.events, Unset):
             events = []

blaxel/core/client/models/sandbox_definition.py

@@ -50,6 +50,7 @@ class SandboxDefinition:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         categories: Union[Unset, list[Any]] = UNSET
         if not isinstance(self.categories, Unset):
             categories = self.categories

blaxel/core/client/models/sandbox_lifecycle.py

@@ -24,6 +24,7 @@ class SandboxLifecycle:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         expiration_policies: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.expiration_policies, Unset):
             expiration_policies = []

blaxel/core/client/models/sandbox_spec.py

@@ -8,7 +8,6 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.core_spec_configurations import CoreSpecConfigurations
     from ..models.flavor import Flavor
-    from ..models.model_private_cluster import ModelPrivateCluster
     from ..models.revision_configuration import RevisionConfiguration
     from ..models.runtime import Runtime
     from ..models.sandbox_lifecycle import SandboxLifecycle
@@ -28,7 +27,6 @@ class SandboxSpec:
         flavors (Union[Unset, list['Flavor']]): Types of hardware available for deployments
         integration_connections (Union[Unset, list[str]]):
         policies (Union[Unset, list[str]]):
-        private_clusters (Union[Unset, ModelPrivateCluster]): Private cluster where the model deployment is deployed
         revision (Union[Unset, RevisionConfiguration]): Revision configuration
         runtime (Union[Unset, Runtime]): Set of configurations for a deployment
         sandbox (Union[Unset, bool]): Sandbox mode
@@ -42,7 +40,6 @@ class SandboxSpec:
     flavors: Union[Unset, list["Flavor"]] = UNSET
     integration_connections: Union[Unset, list[str]] = UNSET
     policies: Union[Unset, list[str]] = UNSET
-    private_clusters: Union[Unset, "ModelPrivateCluster"] = UNSET
     revision: Union[Unset, "RevisionConfiguration"] = UNSET
     runtime: Union[Unset, "Runtime"] = UNSET
     sandbox: Union[Unset, bool] = UNSET
@@ -52,6 +49,7 @@ class SandboxSpec:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         configurations: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.configurations
@@ -82,16 +80,6 @@ class SandboxSpec:
         if not isinstance(self.policies, Unset):
             policies = self.policies
 
-        private_clusters: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.private_clusters
-            and not isinstance(self.private_clusters, Unset)
-            and not isinstance(self.private_clusters, dict)
-        ):
-            private_clusters = self.private_clusters.to_dict()
-        elif self.private_clusters and isinstance(self.private_clusters, dict):
-            private_clusters = self.private_clusters
-
         revision: Union[Unset, dict[str, Any]] = UNSET
         if self.revision and not isinstance(self.revision, Unset) and not isinstance(self.revision, dict):
             revision = self.revision.to_dict()
@@ -137,8 +125,6 @@ class SandboxSpec:
             field_dict["integrationConnections"] = integration_connections
         if policies is not UNSET:
             field_dict["policies"] = policies
-        if private_clusters is not UNSET:
-            field_dict["privateClusters"] = private_clusters
         if revision is not UNSET:
             field_dict["revision"] = revision
         if runtime is not UNSET:
@@ -158,7 +144,6 @@ class SandboxSpec:
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
         from ..models.core_spec_configurations import CoreSpecConfigurations
         from ..models.flavor import Flavor
-        from ..models.model_private_cluster import ModelPrivateCluster
         from ..models.revision_configuration import RevisionConfiguration
         from ..models.runtime import Runtime
         from ..models.sandbox_lifecycle import SandboxLifecycle
@@ -187,13 +172,6 @@ class SandboxSpec:
 
         policies = cast(list[str], d.pop("policies", UNSET))
 
-        _private_clusters = d.pop("privateClusters", UNSET)
-        private_clusters: Union[Unset, ModelPrivateCluster]
-        if isinstance(_private_clusters, Unset):
-            private_clusters = UNSET
-        else:
-            private_clusters = ModelPrivateCluster.from_dict(_private_clusters)
-
         _revision = d.pop("revision", UNSET)
         revision: Union[Unset, RevisionConfiguration]
         if isinstance(_revision, Unset):
@@ -234,7 +212,6 @@ class SandboxSpec:
             flavors=flavors,
             integration_connections=integration_connections,
             policies=policies,
-            private_clusters=private_clusters,
             revision=revision,
             runtime=runtime,
             sandbox=sandbox,

blaxel/core/client/models/serverless_config.py

@@ -33,6 +33,7 @@ class ServerlessConfig:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         configuration: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.configuration

blaxel/core/client/models/start_sandbox.py

@@ -28,6 +28,7 @@ class StartSandbox:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         message = self.message
 
         metadata: Union[Unset, dict[str, Any]] = UNSET

blaxel/core/client/models/stop_sandbox.py

@@ -28,6 +28,7 @@ class StopSandbox:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         message = self.message
 
         metadata: Union[Unset, dict[str, Any]] = UNSET

blaxel/core/client/models/store_agent.py

@@ -45,6 +45,7 @@ class StoreAgent:
     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

blaxel/core/client/models/store_configuration.py

@@ -40,6 +40,7 @@ class StoreConfiguration:
     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

blaxel/core/client/models/template.py

@@ -46,6 +46,7 @@ class Template:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         default_branch = self.default_branch
 
         description = self.description

blaxel/core/client/models/time_to_first_token_over_time_metrics.py

@@ -25,6 +25,7 @@ class TimeToFirstTokenOverTimeMetrics:
     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 = []

blaxel/core/client/models/token_rate_metrics.py

@@ -28,6 +28,7 @@ class TokenRateMetrics:
     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 = []

blaxel/core/client/models/trigger.py

@@ -18,16 +18,19 @@ class Trigger:
 
     Attributes:
         configuration (Union[Unset, TriggerConfiguration]): Trigger configuration
+        enabled (Union[Unset, bool]): Enable or disable the trigger (default: true)
         id (Union[Unset, str]): The id of the trigger
         type_ (Union[Unset, str]): The type of trigger, can be http or http-async
     """
 
     configuration: Union[Unset, "TriggerConfiguration"] = UNSET
+    enabled: Union[Unset, bool] = UNSET
     id: Union[Unset, str] = UNSET
     type_: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         configuration: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.configuration
@@ -38,6 +41,8 @@ class Trigger:
         elif self.configuration and isinstance(self.configuration, dict):
             configuration = self.configuration
 
+        enabled = self.enabled
+
         id = self.id
 
         type_ = self.type_
@@ -47,6 +52,8 @@ class Trigger:
         field_dict.update({})
         if configuration is not UNSET:
             field_dict["configuration"] = configuration
+        if enabled is not UNSET:
+            field_dict["enabled"] = enabled
         if id is not UNSET:
             field_dict["id"] = id
         if type_ is not UNSET:
@@ -68,12 +75,15 @@ class Trigger:
         else:
             configuration = TriggerConfiguration.from_dict(_configuration)
 
+        enabled = d.pop("enabled", UNSET)
+
         id = d.pop("id", UNSET)
 
         type_ = d.pop("type", UNSET)
 
         trigger = cls(
             configuration=configuration,
+            enabled=enabled,
             id=id,
             type_=type_,
         )

blaxel/core/client/models/trigger_configuration.py

@@ -18,22 +18,33 @@ class TriggerConfiguration:
 
     Attributes:
         authentication_type (Union[Unset, str]): The authentication type of the trigger
+        callback_secret (Union[Unset, str]): The callback secret for async triggers (auto-generated, encrypted)
+        callback_url (Union[Unset, str]): The callback URL for async triggers (optional)
         path (Union[Unset, str]): The path of the trigger
         retry (Union[Unset, int]): The retry of the trigger
         schedule (Union[Unset, str]): The schedule of the trigger, cron expression * * * * *
         tasks (Union[Unset, list['TriggerConfigurationTask']]): The tasks configuration of the cronjob
+        timeout (Union[Unset, int]): The timeout in seconds for async triggers (max 900s, MK3 only)
     """
 
     authentication_type: Union[Unset, str] = UNSET
+    callback_secret: Union[Unset, str] = UNSET
+    callback_url: Union[Unset, str] = UNSET
     path: Union[Unset, str] = UNSET
     retry: Union[Unset, int] = UNSET
     schedule: Union[Unset, str] = UNSET
     tasks: Union[Unset, list["TriggerConfigurationTask"]] = UNSET
+    timeout: Union[Unset, int] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         authentication_type = self.authentication_type
 
+        callback_secret = self.callback_secret
+
+        callback_url = self.callback_url
+
         path = self.path
 
         retry = self.retry
@@ -50,11 +61,17 @@ class TriggerConfiguration:
                     tasks_item = tasks_item_data.to_dict()
                 tasks.append(tasks_item)
 
+        timeout = self.timeout
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
         if authentication_type is not UNSET:
             field_dict["authenticationType"] = authentication_type
+        if callback_secret is not UNSET:
+            field_dict["callbackSecret"] = callback_secret
+        if callback_url is not UNSET:
+            field_dict["callbackUrl"] = callback_url
         if path is not UNSET:
             field_dict["path"] = path
         if retry is not UNSET:
@@ -63,6 +80,8 @@ class TriggerConfiguration:
             field_dict["schedule"] = schedule
         if tasks is not UNSET:
             field_dict["tasks"] = tasks
+        if timeout is not UNSET:
+            field_dict["timeout"] = timeout
 
         return field_dict
 
@@ -75,6 +94,10 @@ class TriggerConfiguration:
         d = src_dict.copy()
         authentication_type = d.pop("authenticationType", UNSET)
 
+        callback_secret = d.pop("callbackSecret", UNSET)
+
+        callback_url = d.pop("callbackUrl", UNSET)
+
         path = d.pop("path", UNSET)
 
         retry = d.pop("retry", UNSET)
@@ -88,12 +111,17 @@ class TriggerConfiguration:
 
             tasks.append(tasks_item)
 
+        timeout = d.pop("timeout", UNSET)
+
         trigger_configuration = cls(
             authentication_type=authentication_type,
+            callback_secret=callback_secret,
+            callback_url=callback_url,
             path=path,
             retry=retry,
             schedule=schedule,
             tasks=tasks,
+            timeout=timeout,
         )
 
         trigger_configuration.additional_properties = d

blaxel/core/client/models/volume.py

@@ -37,6 +37,7 @@ class Volume:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         events: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.events, Unset):
             events = []

blaxel/core/client/models/volume_template.py

@@ -33,6 +33,7 @@ class VolumeTemplate:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+
         metadata: Union[Unset, dict[str, Any]] = UNSET
         if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
             metadata = self.metadata.to_dict()

blaxel/core/client/models/websocket_channel.py

@@ -16,12 +16,14 @@ class WebsocketChannel:
         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
         connection_id (Union[Unset, str]): Unique connection ID
+        source_region (Union[Unset, str]): Source region the connection belongs to
         workspace (Union[Unset, str]): Workspace the connection belongs to
     """
 
     created_at: Union[Unset, str] = UNSET
     updated_at: Union[Unset, str] = UNSET
     connection_id: Union[Unset, str] = UNSET
+    source_region: Union[Unset, str] = UNSET
     workspace: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -32,6 +34,8 @@ class WebsocketChannel:
 
         connection_id = self.connection_id
 
+        source_region = self.source_region
+
         workspace = self.workspace
 
         field_dict: dict[str, Any] = {}
@@ -43,6 +47,8 @@ class WebsocketChannel:
             field_dict["updatedAt"] = updated_at
         if connection_id is not UNSET:
             field_dict["connection_id"] = connection_id
+        if source_region is not UNSET:
+            field_dict["sourceRegion"] = source_region
         if workspace is not UNSET:
             field_dict["workspace"] = workspace
 
@@ -59,12 +65,15 @@ class WebsocketChannel:
 
         connection_id = d.pop("connection_id", UNSET)
 
+        source_region = d.pop("sourceRegion", UNSET)
+
         workspace = d.pop("workspace", UNSET)
 
         websocket_channel = cls(
             created_at=created_at,
             updated_at=updated_at,
             connection_id=connection_id,
+            source_region=source_region,
             workspace=workspace,
         )
 

blaxel/core/client/models/workspace.py

@@ -50,6 +50,7 @@ class Workspace:
     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

blaxel/core/client/response_interceptor.py

@@ -94,4 +94,3 @@ response_interceptors_sync = [
 response_interceptors_async = [
     authentication_error_interceptor_async,
 ]
-

blaxel/core/common/__init__.py

@@ -1,14 +1,23 @@
-from .autoload import autoload, capture_exception
+from .autoload import autoload
 from .env import env
 from .internal import get_alphanumeric_limited_hash, get_global_unique_hash
 from .settings import Settings, settings
+from .webhook import (
+    AsyncSidecarCallback,
+    RequestLike,
+    verify_webhook_from_request,
+    verify_webhook_signature,
+)
 
 __all__ = [
     "autoload",
-    "capture_exception",
     "Settings",
     "settings",
     "env",
     "get_alphanumeric_limited_hash",
     "get_global_unique_hash",
+    "verify_webhook_signature",
+    "verify_webhook_from_request",
+    "AsyncSidecarCallback",
+    "RequestLike",
 ]

blaxel/core/common/autoload.py

@@ -1,91 +1,12 @@
-import atexit
 import logging
-import sys
-import threading
-
-from sentry_sdk import Client, Hub
 
 from ..client import client
-from ..client.response_interceptor import (
-    response_interceptors_async,
-    response_interceptors_sync,
-)
+from ..client.response_interceptor import response_interceptors_async, response_interceptors_sync
 from ..sandbox.client import client as client_sandbox
 from .settings import settings
 
 logger = logging.getLogger(__name__)
 
-# Isolated Sentry hub for SDK-only error tracking (doesn't interfere with user's Sentry)
-_sentry_hub: Hub | None = None
-_captured_exceptions: set = set()  # Track already captured exceptions to avoid duplicates
-
-
-def _trace_blaxel_exceptions(frame, event, arg):
-    """Trace function that captures exceptions from blaxel SDK code."""
-    if event == 'exception':
-        exc_type, exc_value, exc_tb = arg
-        filename = frame.f_code.co_filename
-
-        # Only capture if it's from blaxel in site-packages
-        if 'site-packages/blaxel' in filename:
-            # Avoid capturing the same exception multiple times
-            exc_id = id(exc_value)
-            if exc_id not in _captured_exceptions:
-                _captured_exceptions.add(exc_id)
-                capture_exception(exc_value)
-                # Clean up old exception IDs to prevent memory leak
-                if len(_captured_exceptions) > 1000:
-                    _captured_exceptions.clear()
-
-    return _trace_blaxel_exceptions
-
-
-def sentry() -> None:
-    """Initialize an isolated Sentry client for SDK error tracking."""
-    global _sentry_hub
-    try:
-        dsn = settings.sentry_dsn
-        if not dsn:
-            return
-
-        # Create an isolated client that won't interfere with user's Sentry
-        sentry_client = Client(
-            dsn=dsn,
-            environment=settings.env,
-            release=f"sdk-python@{settings.version}",
-            default_integrations=False,
-            auto_enabling_integrations=False,
-        )
-        _sentry_hub = Hub(sentry_client)
-
-        # Set SDK-specific tags
-        with _sentry_hub.configure_scope() as scope:
-            scope.set_tag("blaxel.workspace", settings.workspace)
-            scope.set_tag("blaxel.version", settings.version)
-            scope.set_tag("blaxel.commit", settings.commit)
-
-        # Install trace function to automatically capture SDK exceptions
-        sys.settrace(_trace_blaxel_exceptions)
-        threading.settrace(_trace_blaxel_exceptions)
-
-        # Register atexit handler to flush pending events
-        atexit.register(_flush_sentry)
-
-    except Exception as e:
-        logger.debug(f"Error initializing Sentry: {e}")
-
-
-def capture_exception(exception: Exception | None = None) -> None:
-    """Capture an exception to the SDK's isolated Sentry hub."""
-    if _sentry_hub is not None and _sentry_hub.client is not None:
-        _sentry_hub.capture_exception(exception)
-
-
-def _flush_sentry():
-    """Flush pending Sentry events on program exit."""
-    if _sentry_hub is not None and _sentry_hub.client is not None:
-        _sentry_hub.client.flush(timeout=2)
-
 
 def telemetry() -> None:
     from blaxel.telemetry import telemetry_manager
@@ -112,11 +33,6 @@ def autoload() -> None:
     httpx_sandbox_async_client = client_sandbox.get_async_httpx_client()
     httpx_sandbox_async_client.event_hooks["response"] = response_interceptors_async
 
-    try:
-        sentry()
-    except Exception:
-        pass
-
     try:
         telemetry()
     except Exception: