blaxel 0.2.35__py3-none-any.whl → 0.2.36__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, 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()
+        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) -> 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/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/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, Any] | 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, Any] | 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:
         """

blaxel/core/sandbox/default/sandbox.py

@@ -8,10 +8,11 @@ from ...client.api.compute.get_sandbox import asyncio as get_sandbox
 from ...client.api.compute.list_sandboxes import asyncio as list_sandboxes
 from ...client.api.compute.update_sandbox import asyncio as update_sandbox
 from ...client.client import client
-from ...client.models import Metadata, Sandbox, SandboxRuntime, SandboxSpec
+from ...client.models import Metadata, Sandbox, SandboxLifecycle, SandboxRuntime, SandboxSpec
 from ...client.models.error import Error
 from ...client.models.sandbox_error import SandboxError
 from ...client.types import UNSET
+from ...common.settings import settings
 from ..types import (
     SandboxConfiguration,
     SandboxCreateConfiguration,
@@ -162,7 +163,7 @@ class SandboxInstance:
             volumes = config._normalize_volumes() or UNSET
             ttl = config.ttl
             expires = config.expires
-            region = config.region
+            region = config.region or settings.region
             lifecycle = config.lifecycle
             # snapshot_enabled = sandbox.snapshot_enabled
 
@@ -304,6 +305,72 @@ class SandboxInstance:
         # Return new instance with updated sandbox
         return cls(response)
 
+    @classmethod
+    async def update_ttl(cls, sandbox_name: str, ttl: str) -> "SandboxInstance":
+        """Update sandbox TTL without recreating it.
+
+        Args:
+            sandbox_name: The name of the sandbox to update
+            ttl: The new TTL value (e.g., "5m", "1h", "30s")
+
+        Returns:
+            A new SandboxInstance with updated TTL
+        """
+        # Get the existing sandbox
+        sandbox_instance = await cls.get(sandbox_name)
+        sandbox = sandbox_instance.sandbox
+
+        # Prepare the updated sandbox object
+        updated_sandbox = Sandbox.from_dict(sandbox.to_dict())
+        if updated_sandbox.spec is None or updated_sandbox.spec.runtime is None:
+            raise ValueError(f"Sandbox {sandbox_name} has invalid spec")
+
+        # Update TTL
+        updated_sandbox.spec.runtime.ttl = ttl
+
+        # Call the update API
+        response = await update_sandbox(
+            sandbox_name=sandbox_name,
+            client=client,
+            body=updated_sandbox,
+        )
+
+        return cls(response)
+
+    @classmethod
+    async def update_lifecycle(
+        cls, sandbox_name: str, lifecycle: SandboxLifecycle
+    ) -> "SandboxInstance":
+        """Update sandbox lifecycle configuration without recreating it.
+
+        Args:
+            sandbox_name: The name of the sandbox to update
+            lifecycle: The new lifecycle configuration
+
+        Returns:
+            A new SandboxInstance with updated lifecycle
+        """
+        # Get the existing sandbox
+        sandbox_instance = await cls.get(sandbox_name)
+        sandbox = sandbox_instance.sandbox
+
+        # Prepare the updated sandbox object
+        updated_sandbox = Sandbox.from_dict(sandbox.to_dict())
+        if updated_sandbox.spec is None:
+            raise ValueError(f"Sandbox {sandbox_name} has invalid spec")
+
+        # Update lifecycle
+        updated_sandbox.spec.lifecycle = lifecycle
+
+        # Call the update API
+        response = await update_sandbox(
+            sandbox_name=sandbox_name,
+            client=client,
+            body=updated_sandbox,
+        )
+
+        return cls(response)
+
     @classmethod
     async def create_if_not_exists(
         cls, sandbox: Union[Sandbox, SandboxCreateConfiguration, Dict[str, Any]]