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

blaxel/core/client/models/create_job_execution_request_env.py

@@ -0,0 +1,50 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CreateJobExecutionRequestEnv")
+
+
+@_attrs_define
+class CreateJobExecutionRequestEnv:
+    """Environment variable overrides (optional, will merge with job's environment variables)
+
+    Example:
+        {"MY_VAR": "custom_value", "BATCH_SIZE": "100"}
+
+    """
+
+    additional_properties: dict[str, str] = _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 | None:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        create_job_execution_request_env = cls()
+
+        create_job_execution_request_env.additional_properties = d
+        return create_job_execution_request_env
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/function_runtime.py

@@ -4,6 +4,7 @@ from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
 from ..models.function_runtime_generation import FunctionRuntimeGeneration
+from ..models.function_runtime_transport import FunctionRuntimeTransport
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
@@ -29,6 +30,8 @@ class FunctionRuntime:
             in MB / 2048, e.g., 4096MB = 2 CPUs). Example: 2048.
         min_scale (Union[Unset, int]): Minimum instances to keep warm. Set to 1+ to eliminate cold starts, 0 for scale-
             to-zero.
+        transport (Union[Unset, FunctionRuntimeTransport]): Transport compatibility for the MCP, can be "websocket" or
+            "http-stream" Example: http-stream.
     """
 
     envs: Union[Unset, list["Env"]] = UNSET
@@ -37,6 +40,7 @@ class FunctionRuntime:
     max_scale: Union[Unset, int] = UNSET
     memory: Union[Unset, int] = UNSET
     min_scale: Union[Unset, int] = UNSET
+    transport: Union[Unset, FunctionRuntimeTransport] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -62,6 +66,10 @@ class FunctionRuntime:
 
         min_scale = self.min_scale
 
+        transport: Union[Unset, str] = UNSET
+        if not isinstance(self.transport, Unset):
+            transport = self.transport.value
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
@@ -77,6 +85,8 @@ class FunctionRuntime:
             field_dict["memory"] = memory
         if min_scale is not UNSET:
             field_dict["minScale"] = min_scale
+        if transport is not UNSET:
+            field_dict["transport"] = transport
 
         return field_dict
 
@@ -109,6 +119,13 @@ class FunctionRuntime:
 
         min_scale = d.pop("minScale", d.pop("min_scale", UNSET))
 
+        _transport = d.pop("transport", UNSET)
+        transport: Union[Unset, FunctionRuntimeTransport]
+        if isinstance(_transport, Unset):
+            transport = UNSET
+        else:
+            transport = FunctionRuntimeTransport(_transport)
+
         function_runtime = cls(
             envs=envs,
             generation=generation,
@@ -116,6 +133,7 @@ class FunctionRuntime:
             max_scale=max_scale,
             memory=memory,
             min_scale=min_scale,
+            transport=transport,
         )
 
         function_runtime.additional_properties = d

blaxel/core/client/models/{function_spec_transport.py → function_runtime_transport.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class FunctionSpecTransport(str, Enum):
+class FunctionRuntimeTransport(str, Enum):
     HTTP_STREAM = "http-stream"
     WEBSOCKET = "websocket"
 
@@ -9,7 +9,7 @@ class FunctionSpecTransport(str, Enum):
         return str(self.value)
 
     @classmethod
-    def _missing_(cls, value: object) -> "FunctionSpecTransport | None":
+    def _missing_(cls, value: object) -> "FunctionRuntimeTransport | None":
         if isinstance(value, str):
             upper_value = value.upper()
             for member in cls:

blaxel/core/client/models/function_spec.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..models.function_spec_transport import FunctionSpecTransport
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
@@ -27,8 +26,6 @@ class FunctionSpec:
         revision (Union[Unset, RevisionConfiguration]): Revision configuration
         runtime (Union[Unset, FunctionRuntime]): Runtime configuration defining how the MCP server function is deployed
             and scaled
-        transport (Union[Unset, FunctionSpecTransport]): Transport compatibility for the MCP, can be "websocket" or
-            "http-stream" Example: http-stream.
         triggers (Union[Unset, list['Trigger']]): Triggers to use your agent
     """
 
@@ -37,7 +34,6 @@ class FunctionSpec:
     policies: Union[Unset, list[str]] = UNSET
     revision: Union[Unset, "RevisionConfiguration"] = UNSET
     runtime: Union[Unset, "FunctionRuntime"] = UNSET
-    transport: Union[Unset, FunctionSpecTransport] = UNSET
     triggers: Union[Unset, list["Trigger"]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -72,10 +68,6 @@ class FunctionSpec:
         elif self.runtime and isinstance(self.runtime, dict):
             runtime = self.runtime
 
-        transport: Union[Unset, str] = UNSET
-        if not isinstance(self.transport, Unset):
-            transport = self.transport.value
-
         triggers: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.triggers, Unset):
             triggers = []
@@ -99,8 +91,6 @@ class FunctionSpec:
             field_dict["revision"] = revision
         if runtime is not UNSET:
             field_dict["runtime"] = runtime
-        if transport is not UNSET:
-            field_dict["transport"] = transport
         if triggers is not UNSET:
             field_dict["triggers"] = triggers
 
@@ -137,13 +127,6 @@ class FunctionSpec:
         else:
             runtime = FunctionRuntime.from_dict(_runtime)
 
-        _transport = d.pop("transport", UNSET)
-        transport: Union[Unset, FunctionSpecTransport]
-        if isinstance(_transport, Unset):
-            transport = UNSET
-        else:
-            transport = FunctionSpecTransport(_transport)
-
         triggers = []
         _triggers = d.pop("triggers", UNSET)
         for componentsschemas_triggers_item_data in _triggers or []:
@@ -159,7 +142,6 @@ class FunctionSpec:
             policies=policies,
             revision=revision,
             runtime=runtime,
-            transport=transport,
             triggers=triggers,
         )
 

blaxel/core/client/models/job_execution_spec.py

@@ -6,6 +6,7 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
+    from ..models.job_execution_spec_env_override import JobExecutionSpecEnvOverride
     from ..models.job_execution_task import JobExecutionTask
 
 
@@ -17,17 +18,35 @@ class JobExecutionSpec:
     """Job execution specification
 
     Attributes:
+        env_override (Union[Unset, JobExecutionSpecEnvOverride]): Environment variable overrides (if provided for this
+            execution, values are masked with ***) Example: {"MY_VAR": "***", "BATCH_SIZE": "***"}.
+        memory_override (Union[Unset, int]): Memory override in megabytes (if provided for this execution) Example:
+            2048.
         parallelism (Union[Unset, int]): Number of parallel tasks Example: 5.
         tasks (Union[Unset, list['JobExecutionTask']]): List of execution tasks
         timeout (Union[Unset, int]): Job timeout in seconds (captured at execution creation time) Example: 3600.
     """
 
+    env_override: Union[Unset, "JobExecutionSpecEnvOverride"] = UNSET
+    memory_override: Union[Unset, int] = UNSET
     parallelism: Union[Unset, int] = UNSET
     tasks: Union[Unset, list["JobExecutionTask"]] = UNSET
     timeout: Union[Unset, int] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        env_override: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.env_override
+            and not isinstance(self.env_override, Unset)
+            and not isinstance(self.env_override, dict)
+        ):
+            env_override = self.env_override.to_dict()
+        elif self.env_override and isinstance(self.env_override, dict):
+            env_override = self.env_override
+
+        memory_override = self.memory_override
+
         parallelism = self.parallelism
 
         tasks: Union[Unset, list[dict[str, Any]]] = UNSET
@@ -45,6 +64,10 @@ class JobExecutionSpec:
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
+        if env_override is not UNSET:
+            field_dict["envOverride"] = env_override
+        if memory_override is not UNSET:
+            field_dict["memoryOverride"] = memory_override
         if parallelism is not UNSET:
             field_dict["parallelism"] = parallelism
         if tasks is not UNSET:
@@ -56,11 +79,21 @@ class JobExecutionSpec:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        from ..models.job_execution_spec_env_override import JobExecutionSpecEnvOverride
         from ..models.job_execution_task import JobExecutionTask
 
         if not src_dict:
             return None
         d = src_dict.copy()
+        _env_override = d.pop("envOverride", d.pop("env_override", UNSET))
+        env_override: Union[Unset, JobExecutionSpecEnvOverride]
+        if isinstance(_env_override, Unset):
+            env_override = UNSET
+        else:
+            env_override = JobExecutionSpecEnvOverride.from_dict(_env_override)
+
+        memory_override = d.pop("memoryOverride", d.pop("memory_override", UNSET))
+
         parallelism = d.pop("parallelism", UNSET)
 
         tasks = []
@@ -73,6 +106,8 @@ class JobExecutionSpec:
         timeout = d.pop("timeout", UNSET)
 
         job_execution_spec = cls(
+            env_override=env_override,
+            memory_override=memory_override,
             parallelism=parallelism,
             tasks=tasks,
             timeout=timeout,

blaxel/core/client/models/job_execution_spec_env_override.py

@@ -0,0 +1,50 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="JobExecutionSpecEnvOverride")
+
+
+@_attrs_define
+class JobExecutionSpecEnvOverride:
+    """Environment variable overrides (if provided for this execution, values are masked with ***)
+
+    Example:
+        {"MY_VAR": "***", "BATCH_SIZE": "***"}
+
+    """
+
+    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 | None:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        job_execution_spec_env_override = cls()
+
+        job_execution_spec_env_override.additional_properties = d
+        return job_execution_spec_env_override
+
+    @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/port_protocol.py

@@ -4,6 +4,7 @@ from enum import Enum
 class PortProtocol(str, Enum):
     HTTP = "HTTP"
     TCP = "TCP"
+    TLS = "TLS"
     UDP = "UDP"
 
     def __str__(self) -> str:

blaxel/core/client/models/preview.py

@@ -1,9 +1,13 @@
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.status import Status
+from ..types import UNSET, Unset
+
 if TYPE_CHECKING:
+    from ..models.core_event import CoreEvent
     from ..models.preview_metadata import PreviewMetadata
     from ..models.preview_spec import PreviewSpec
 
@@ -18,10 +22,14 @@ class Preview:
     Attributes:
         metadata (PreviewMetadata): PreviewMetadata
         spec (PreviewSpec): Preview of a Resource
+        events (Union[Unset, list['CoreEvent']]): Events happening on a resource deployed on Blaxel
+        status (Union[Unset, Status]): Deployment status of a resource deployed on Blaxel
     """
 
     metadata: "PreviewMetadata"
     spec: "PreviewSpec"
+    events: Union[Unset, list["CoreEvent"]] = UNSET
+    status: Union[Unset, Status] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -35,6 +43,22 @@ class Preview:
         else:
             spec = self.spec.to_dict()
 
+        events: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.events, Unset):
+            events = []
+            for componentsschemas_core_events_item_data in self.events:
+                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()
+                    )
+                events.append(componentsschemas_core_events_item)
+
+        status: Union[Unset, str] = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -43,11 +67,16 @@ class Preview:
                 "spec": spec,
             }
         )
+        if events is not UNSET:
+            field_dict["events"] = events
+        if status is not UNSET:
+            field_dict["status"] = status
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        from ..models.core_event import CoreEvent
         from ..models.preview_metadata import PreviewMetadata
         from ..models.preview_spec import PreviewSpec
 
@@ -58,9 +87,27 @@ class Preview:
 
         spec = PreviewSpec.from_dict(d.pop("spec"))
 
+        events = []
+        _events = d.pop("events", UNSET)
+        for componentsschemas_core_events_item_data in _events or []:
+            componentsschemas_core_events_item = CoreEvent.from_dict(
+                componentsschemas_core_events_item_data
+            )
+
+            events.append(componentsschemas_core_events_item)
+
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, Status]
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = Status(_status)
+
         preview = cls(
             metadata=metadata,
             spec=spec,
+            events=events,
+            status=status,
         )
 
         preview.additional_properties = d

blaxel/core/client/models/sandbox.py

@@ -26,6 +26,8 @@ class Sandbox:
             spec (SandboxSpec): Configuration for a sandbox including its image, memory, ports, region, and lifecycle
                 policies
             events (Union[Unset, list['CoreEvent']]): Events happening on a resource deployed on Blaxel
+            expires_in (Union[Unset, int]): Time in seconds until the sandbox is automatically deleted based on TTL and
+                lifecycle policies. Only present for sandboxes with lifecycle configured.
             last_used_at (Union[Unset, str]): Last time the sandbox was used (read-only, managed by the system)
             status (Union[Unset, Status]): Deployment status of a resource deployed on Blaxel
     """
@@ -33,6 +35,7 @@ class Sandbox:
     metadata: "Metadata"
     spec: "SandboxSpec"
     events: Union[Unset, list["CoreEvent"]] = UNSET
+    expires_in: Union[Unset, int] = UNSET
     last_used_at: Union[Unset, str] = UNSET
     status: Union[Unset, Status] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -60,6 +63,8 @@ class Sandbox:
                     )
                 events.append(componentsschemas_core_events_item)
 
+        expires_in = self.expires_in
+
         last_used_at = self.last_used_at
 
         status: Union[Unset, str] = UNSET
@@ -76,6 +81,8 @@ class Sandbox:
         )
         if events is not UNSET:
             field_dict["events"] = events
+        if expires_in is not UNSET:
+            field_dict["expiresIn"] = expires_in
         if last_used_at is not UNSET:
             field_dict["lastUsedAt"] = last_used_at
         if status is not UNSET:
@@ -105,6 +112,8 @@ class Sandbox:
 
             events.append(componentsschemas_core_events_item)
 
+        expires_in = d.pop("expiresIn", d.pop("expires_in", UNSET))
+
         last_used_at = d.pop("lastUsedAt", d.pop("last_used_at", UNSET))
 
         _status = d.pop("status", UNSET)
@@ -118,6 +127,7 @@ class Sandbox:
             metadata=metadata,
             spec=spec,
             events=events,
+            expires_in=expires_in,
             last_used_at=last_used_at,
             status=status,
         )

blaxel/core/common/settings.py

@@ -166,5 +166,10 @@ class Settings:
 
         return True
 
+    @property
+    def region(self) -> str | None:
+        """Get the region from BL_REGION environment variable."""
+        return os.environ.get("BL_REGION")
+
 
 settings = Settings()

blaxel/core/jobs/__init__.py

@@ -18,8 +18,6 @@ from ..client.models.create_job_execution_request import (
     CreateJobExecutionRequest,
 )
 from ..client.models.job_execution import JobExecution
-from ..common.internal import get_forced_url, get_global_unique_hash
-from ..common.settings import settings
 
 
 class BlJobWrapper:
@@ -74,99 +72,73 @@ class BlJob:
     def __init__(self, name: str):
         self.name = name
 
-    @property
-    def internal_url(self):
-        """Get the internal URL for the job using a hash of workspace and job name."""
-        hash = get_global_unique_hash(settings.workspace, "job", self.name)
-        return f"{settings.run_internal_protocol}://bl-{settings.env}-{hash}.{settings.run_internal_hostname}"
+    def run(
+        self,
+        tasks: List[Dict[str, Any]],
+        env: Dict[str, str] | None = None,
+        memory: int | None = None,
+        execution_id: str | None = None,
+    ) -> str:
+        """
+        Run the job with the provided tasks and optional overrides.
 
-    @property
-    def forced_url(self):
-        """Get the forced URL from environment variables if set."""
-        return get_forced_url("job", self.name)
+        Args:
+            tasks: List of task parameters for parallel execution
+            env: Optional environment variable overrides (merged with job's environment)
+            memory: Optional memory override in megabytes (must be <= job's configured memory)
+            execution_id: Optional custom execution ID
 
-    @property
-    def external_url(self):
-        return f"{settings.run_url}/{settings.workspace}/jobs/{self.name}"
+        Returns:
+            str: The execution ID
 
-    @property
-    def fallback_url(self):
-        if self.external_url != self.url:
-            return self.external_url
-        return None
+        Raises:
+            Exception: If the job execution fails
+        """
+        logger.debug(f"Job Calling: {self.name}")
 
-    @property
-    def url(self):
-        if self.forced_url:
-            return self.forced_url
-        if settings.run_internal_hostname:
-            return self.internal_url
-        return self.external_url
-
-    def call(self, url, input_data, headers: dict = {}, params: dict = {}):
-        body = {"tasks": input_data}
-
-        # Merge settings headers with provided headers
-        merged_headers = {
-            **settings.headers,
-            "Content-Type": "application/json",
-            **headers,
-        }
-
-        return client.get_httpx_client().post(
-            url + "/executions",
-            headers=merged_headers,
-            json=body,
-            params=params,
-        )
+        request = CreateJobExecutionRequest(tasks=tasks)
+        if env is not None:
+            request.env = env
+        if memory is not None:
+            request.memory = memory
+        if execution_id is not None:
+            request.execution_id = execution_id
 
-    async def acall(self, url, input_data, headers: dict = {}, params: dict = {}):
-        logger.debug(f"Job Calling: {self.name}")
-        body = {"tasks": input_data}
-
-        # Merge settings headers with provided headers
-        merged_headers = {
-            **settings.headers,
-            "Content-Type": "application/json",
-            **headers,
-        }
-
-        return await client.get_async_httpx_client().post(
-            url + "/executions",
-            headers=merged_headers,
-            json=body,
-            params=params,
-        )
+        return self.create_execution(request)
 
-    def run(self, input: Any, headers: dict = {}, params: dict = {}) -> str:
-        logger.debug(f"Job Calling: {self.name}")
-        response = self.call(self.url, input, headers, params)
-        if response.status_code >= 400:
-            if not self.fallback_url:
-                raise Exception(
-                    f"Job {self.name} returned status code {response.status_code} with body {response.text}"
-                )
-            response = self.call(self.fallback_url, input, headers, params)
-            if response.status_code >= 400:
-                raise Exception(
-                    f"Job {self.name} returned status code {response.status_code} with body {response.text}"
-                )
-        return response.text
-
-    async def arun(self, input: Any, headers: dict = {}, params: dict = {}) -> str:
+    async def arun(
+        self,
+        tasks: List[Dict[str, Any]],
+        env: Dict[str, str] | None = None,
+        memory: int | None = None,
+        execution_id: str | None = None,
+    ) -> str:
+        """
+        Run the job with the provided tasks and optional overrides (async).
+
+        Args:
+            tasks: List of task parameters for parallel execution
+            env: Optional environment variable overrides (merged with job's environment)
+            memory: Optional memory override in megabytes (must be <= job's configured memory)
+            execution_id: Optional custom execution ID
+
+        Returns:
+            str: The execution ID
+
+        Raises:
+            Exception: If the job execution fails
+        """
         logger.debug(f"Job Calling: {self.name}")
-        response = await self.acall(self.url, input, headers, params)
-        if response.status_code >= 400:
-            if not self.fallback_url:
-                raise Exception(
-                    f"Job {self.name} returned status code {response.status_code} with body {response.text}"
-                )
-            response = await self.acall(self.fallback_url, input, headers, params)
-            if response.status_code >= 400:
-                raise Exception(
-                    f"Job {self.name} returned status code {response.status_code} with body {response.text}"
-                )
-        return response.text
+
+        request = CreateJobExecutionRequest(tasks=tasks)
+        if env is not None:
+            request.env = env
+        if memory is not None:
+            request.memory = memory
+        if execution_id is not None:
+            request.execution_id = execution_id
+
+        return await self.acreate_execution(request)
 
     def create_execution(self, request: CreateJobExecutionRequest) -> str:
         """