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

blaxel/core/client/models/sandbox_error.py

@@ -0,0 +1,148 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sandbox_error_details import SandboxErrorDetails
+
+
+T = TypeVar("T", bound="SandboxError")
+
+
+@_attrs_define
+class SandboxError:
+    """Error response returned by the CreateSandbox endpoint with extended details about the failure
+
+    Attributes:
+        code (str): Error code identifying the kind of error (e.g., INVALID_IMAGE, QUOTA_EXCEEDED) Example:
+            INVALID_IMAGE.
+        message (str): Human-readable error message describing what went wrong Example: Sandbox image blaxel/dev-ts-
+            app:latest is not supported.
+        details (Union[Unset, SandboxErrorDetails]): Additional error details. For INVALID_IMAGE errors, includes
+            requested_image and supported_images array.
+        sandbox_name (Union[Unset, str]): Name of the sandbox that failed to create Example: mysandbox.
+        status_code (Union[Unset, int]): HTTP status code Example: 400.
+        step (Union[Unset, str]): Processing step where the error occurred Example: validate_and_prepare.
+        timestamp (Union[Unset, str]): ISO 8601 timestamp of when the error occurred Example:
+            2025-12-19T22:36:29.336304095Z.
+        workspace (Union[Unset, str]): Workspace name where the sandbox creation was attempted Example: main.
+    """
+
+    code: str
+    message: str
+    details: Union[Unset, "SandboxErrorDetails"] = UNSET
+    sandbox_name: Union[Unset, str] = UNSET
+    status_code: Union[Unset, int] = UNSET
+    step: Union[Unset, str] = UNSET
+    timestamp: 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]:
+        code = self.code
+
+        message = self.message
+
+        details: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.details
+            and not isinstance(self.details, Unset)
+            and not isinstance(self.details, dict)
+        ):
+            details = self.details.to_dict()
+        elif self.details and isinstance(self.details, dict):
+            details = self.details
+
+        sandbox_name = self.sandbox_name
+
+        status_code = self.status_code
+
+        step = self.step
+
+        timestamp = self.timestamp
+
+        workspace = self.workspace
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+            }
+        )
+        if details is not UNSET:
+            field_dict["details"] = details
+        if sandbox_name is not UNSET:
+            field_dict["sandbox_name"] = sandbox_name
+        if status_code is not UNSET:
+            field_dict["status_code"] = status_code
+        if step is not UNSET:
+            field_dict["step"] = step
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        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 | None:
+        from ..models.sandbox_error_details import SandboxErrorDetails
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        code = d.pop("code")
+
+        message = d.pop("message")
+
+        _details = d.pop("details", UNSET)
+        details: Union[Unset, SandboxErrorDetails]
+        if isinstance(_details, Unset):
+            details = UNSET
+        else:
+            details = SandboxErrorDetails.from_dict(_details)
+
+        sandbox_name = d.pop("sandbox_name", UNSET)
+
+        status_code = d.pop("status_code", UNSET)
+
+        step = d.pop("step", UNSET)
+
+        timestamp = d.pop("timestamp", UNSET)
+
+        workspace = d.pop("workspace", UNSET)
+
+        sandbox_error = cls(
+            code=code,
+            message=message,
+            details=details,
+            sandbox_name=sandbox_name,
+            status_code=status_code,
+            step=step,
+            timestamp=timestamp,
+            workspace=workspace,
+        )
+
+        sandbox_error.additional_properties = d
+        return sandbox_error
+
+    @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/sandbox_error_details.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SandboxErrorDetails")
+
+
+@_attrs_define
+class SandboxErrorDetails:
+    """Additional error details. For INVALID_IMAGE errors, includes requested_image and supported_images array."""
+
+    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()
+        sandbox_error_details = cls()
+
+        sandbox_error_details.additional_properties = d
+        return sandbox_error_details
+
+    @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/sandbox_lifecycle.py

@@ -14,10 +14,11 @@ T = TypeVar("T", bound="SandboxLifecycle")
 
 @_attrs_define
 class SandboxLifecycle:
-    """Lifecycle configuration for sandbox management
+    """Lifecycle configuration controlling automatic sandbox deletion based on idle time, max age, or specific dates
 
     Attributes:
-        expiration_policies (Union[Unset, list['ExpirationPolicy']]): List of expiration policies
+        expiration_policies (Union[Unset, list['ExpirationPolicy']]): List of expiration policies. Multiple policies can
+            be combined; whichever condition is met first triggers the action.
     """
 
     expiration_policies: Union[Unset, list["ExpirationPolicy"]] = UNSET

blaxel/core/client/models/sandbox_runtime.py

@@ -0,0 +1,145 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.env import Env
+    from ..models.port import Port
+
+
+T = TypeVar("T", bound="SandboxRuntime")
+
+
+@_attrs_define
+class SandboxRuntime:
+    """Runtime configuration defining how the sandbox VM is provisioned and its resource limits
+
+    Attributes:
+        envs (Union[Unset, list['Env']]): Environment variables injected into the sandbox. Supports Kubernetes EnvVar
+            format with valueFrom references.
+        expires (Union[Unset, str]): Absolute expiration timestamp in ISO 8601 format when the sandbox will be deleted
+            Example: 2025-12-31T23:59:59Z.
+        image (Union[Unset, str]): Sandbox image to use. Can be a public Blaxel image (e.g., blaxel/base-image:latest)
+            or a custom template image built with 'bl deploy'. Example: blaxel/base-image:latest.
+        memory (Union[Unset, int]): Memory allocation in megabytes. Also determines CPU allocation (CPU cores = memory
+            in MB / 2048, e.g., 4096MB = 2 CPUs). Example: 4096.
+        ports (Union[Unset, list['Port']]): Set of ports for a resource
+        ttl (Union[Unset, str]): Time-to-live duration after which the sandbox is automatically deleted (e.g., '30m',
+            '24h', '7d') Example: 24h.
+    """
+
+    envs: Union[Unset, list["Env"]] = UNSET
+    expires: Union[Unset, str] = UNSET
+    image: Union[Unset, str] = UNSET
+    memory: Union[Unset, int] = UNSET
+    ports: Union[Unset, list["Port"]] = UNSET
+    ttl: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        envs: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.envs, Unset):
+            envs = []
+            for envs_item_data in self.envs:
+                if type(envs_item_data) is dict:
+                    envs_item = envs_item_data
+                else:
+                    envs_item = envs_item_data.to_dict()
+                envs.append(envs_item)
+
+        expires = self.expires
+
+        image = self.image
+
+        memory = self.memory
+
+        ports: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.ports, Unset):
+            ports = []
+            for componentsschemas_ports_item_data in self.ports:
+                if type(componentsschemas_ports_item_data) is dict:
+                    componentsschemas_ports_item = componentsschemas_ports_item_data
+                else:
+                    componentsschemas_ports_item = componentsschemas_ports_item_data.to_dict()
+                ports.append(componentsschemas_ports_item)
+
+        ttl = self.ttl
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if envs is not UNSET:
+            field_dict["envs"] = envs
+        if expires is not UNSET:
+            field_dict["expires"] = expires
+        if image is not UNSET:
+            field_dict["image"] = image
+        if memory is not UNSET:
+            field_dict["memory"] = memory
+        if ports is not UNSET:
+            field_dict["ports"] = ports
+        if ttl is not UNSET:
+            field_dict["ttl"] = ttl
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        from ..models.env import Env
+        from ..models.port import Port
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        envs = []
+        _envs = d.pop("envs", UNSET)
+        for envs_item_data in _envs or []:
+            envs_item = Env.from_dict(envs_item_data)
+
+            envs.append(envs_item)
+
+        expires = d.pop("expires", UNSET)
+
+        image = d.pop("image", UNSET)
+
+        memory = d.pop("memory", UNSET)
+
+        ports = []
+        _ports = d.pop("ports", UNSET)
+        for componentsschemas_ports_item_data in _ports or []:
+            componentsschemas_ports_item = Port.from_dict(componentsschemas_ports_item_data)
+
+            ports.append(componentsschemas_ports_item)
+
+        ttl = d.pop("ttl", UNSET)
+
+        sandbox_runtime = cls(
+            envs=envs,
+            expires=expires,
+            image=image,
+            memory=memory,
+            ports=ports,
+            ttl=ttl,
+        )
+
+        sandbox_runtime.additional_properties = d
+        return sandbox_runtime
+
+    @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/sandbox_spec.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -6,11 +6,8 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.core_spec_configurations import CoreSpecConfigurations
-    from ..models.flavor import Flavor
-    from ..models.revision_configuration import RevisionConfiguration
-    from ..models.runtime import Runtime
     from ..models.sandbox_lifecycle import SandboxLifecycle
+    from ..models.sandbox_runtime import SandboxRuntime
     from ..models.volume_attachment import VolumeAttachment
 
 
@@ -19,75 +16,41 @@ T = TypeVar("T", bound="SandboxSpec")
 
 @_attrs_define
 class SandboxSpec:
-    """Sandbox specification
+    """Configuration for a sandbox including its image, memory, ports, region, and lifecycle policies
 
     Attributes:
-        configurations (Union[Unset, CoreSpecConfigurations]): Optional configurations for the object
-        enabled (Union[Unset, bool]): Enable or disable the resource
-        flavors (Union[Unset, list['Flavor']]): Types of hardware available for deployments
-        integration_connections (Union[Unset, list[str]]):
-        policies (Union[Unset, list[str]]):
-        revision (Union[Unset, RevisionConfiguration]): Revision configuration
-        runtime (Union[Unset, Runtime]): Set of configurations for a deployment
-        sandbox (Union[Unset, bool]): Sandbox mode
-        lifecycle (Union[Unset, SandboxLifecycle]): Lifecycle configuration for sandbox management
-        region (Union[Unset, str]): Region where the sandbox should be created (e.g. us-pdx-1, eu-lon-1)
+        enabled (Union[Unset, bool]): When false, the sandbox is disabled and will not accept connections Default: True.
+            Example: True.
+        lifecycle (Union[Unset, SandboxLifecycle]): Lifecycle configuration controlling automatic sandbox deletion based
+            on idle time, max age, or specific dates
+        region (Union[Unset, str]): Region where the sandbox should be created (e.g. us-pdx-1, eu-lon-1). If not
+            specified, defaults to the region closest to the user. Example: us-pdx-1.
+        runtime (Union[Unset, SandboxRuntime]): Runtime configuration defining how the sandbox VM is provisioned and its
+            resource limits
         volumes (Union[Unset, list['VolumeAttachment']]):
     """
 
-    configurations: Union[Unset, "CoreSpecConfigurations"] = UNSET
-    enabled: Union[Unset, bool] = UNSET
-    flavors: Union[Unset, list["Flavor"]] = UNSET
-    integration_connections: Union[Unset, list[str]] = UNSET
-    policies: Union[Unset, list[str]] = UNSET
-    revision: Union[Unset, "RevisionConfiguration"] = UNSET
-    runtime: Union[Unset, "Runtime"] = UNSET
-    sandbox: Union[Unset, bool] = UNSET
+    enabled: Union[Unset, bool] = True
     lifecycle: Union[Unset, "SandboxLifecycle"] = UNSET
     region: Union[Unset, str] = UNSET
+    runtime: Union[Unset, "SandboxRuntime"] = UNSET
     volumes: Union[Unset, list["VolumeAttachment"]] = UNSET
     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
-            and not isinstance(self.configurations, Unset)
-            and not isinstance(self.configurations, dict)
-        ):
-            configurations = self.configurations.to_dict()
-        elif self.configurations and isinstance(self.configurations, dict):
-            configurations = self.configurations
-
         enabled = self.enabled
 
-        flavors: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.flavors, Unset):
-            flavors = []
-            for componentsschemas_flavors_item_data in self.flavors:
-                if type(componentsschemas_flavors_item_data) is dict:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data
-                else:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data.to_dict()
-                flavors.append(componentsschemas_flavors_item)
-
-        integration_connections: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.integration_connections, Unset):
-            integration_connections = self.integration_connections
-
-        policies: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.policies, Unset):
-            policies = self.policies
-
-        revision: Union[Unset, dict[str, Any]] = UNSET
+        lifecycle: Union[Unset, dict[str, Any]] = UNSET
         if (
-            self.revision
-            and not isinstance(self.revision, Unset)
-            and not isinstance(self.revision, dict)
+            self.lifecycle
+            and not isinstance(self.lifecycle, Unset)
+            and not isinstance(self.lifecycle, dict)
         ):
-            revision = self.revision.to_dict()
-        elif self.revision and isinstance(self.revision, dict):
-            revision = self.revision
+            lifecycle = self.lifecycle.to_dict()
+        elif self.lifecycle and isinstance(self.lifecycle, dict):
+            lifecycle = self.lifecycle
+
+        region = self.region
 
         runtime: Union[Unset, dict[str, Any]] = UNSET
         if (
@@ -99,20 +62,6 @@ class SandboxSpec:
         elif self.runtime and isinstance(self.runtime, dict):
             runtime = self.runtime
 
-        sandbox = self.sandbox
-
-        lifecycle: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.lifecycle
-            and not isinstance(self.lifecycle, Unset)
-            and not isinstance(self.lifecycle, dict)
-        ):
-            lifecycle = self.lifecycle.to_dict()
-        elif self.lifecycle and isinstance(self.lifecycle, dict):
-            lifecycle = self.lifecycle
-
-        region = self.region
-
         volumes: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.volumes, Unset):
             volumes = []
@@ -130,26 +79,14 @@ class SandboxSpec:
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
-        if configurations is not UNSET:
-            field_dict["configurations"] = configurations
         if enabled is not UNSET:
             field_dict["enabled"] = enabled
-        if flavors is not UNSET:
-            field_dict["flavors"] = flavors
-        if integration_connections is not UNSET:
-            field_dict["integrationConnections"] = integration_connections
-        if policies is not UNSET:
-            field_dict["policies"] = policies
-        if revision is not UNSET:
-            field_dict["revision"] = revision
-        if runtime is not UNSET:
-            field_dict["runtime"] = runtime
-        if sandbox is not UNSET:
-            field_dict["sandbox"] = sandbox
         if lifecycle is not UNSET:
             field_dict["lifecycle"] = lifecycle
         if region is not UNSET:
             field_dict["region"] = region
+        if runtime is not UNSET:
+            field_dict["runtime"] = runtime
         if volumes is not UNSET:
             field_dict["volumes"] = volumes
 
@@ -157,54 +94,15 @@ class SandboxSpec:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.core_spec_configurations import CoreSpecConfigurations
-        from ..models.flavor import Flavor
-        from ..models.revision_configuration import RevisionConfiguration
-        from ..models.runtime import Runtime
         from ..models.sandbox_lifecycle import SandboxLifecycle
+        from ..models.sandbox_runtime import SandboxRuntime
         from ..models.volume_attachment import VolumeAttachment
 
         if not src_dict:
             return None
         d = src_dict.copy()
-        _configurations = d.pop("configurations", UNSET)
-        configurations: Union[Unset, CoreSpecConfigurations]
-        if isinstance(_configurations, Unset):
-            configurations = UNSET
-        else:
-            configurations = CoreSpecConfigurations.from_dict(_configurations)
-
         enabled = d.pop("enabled", UNSET)
 
-        flavors = []
-        _flavors = d.pop("flavors", UNSET)
-        for componentsschemas_flavors_item_data in _flavors or []:
-            componentsschemas_flavors_item = Flavor.from_dict(componentsschemas_flavors_item_data)
-
-            flavors.append(componentsschemas_flavors_item)
-
-        integration_connections = cast(
-            list[str], d.pop("integrationConnections", d.pop("integration_connections", UNSET))
-        )
-
-        policies = cast(list[str], d.pop("policies", UNSET))
-
-        _revision = d.pop("revision", UNSET)
-        revision: Union[Unset, RevisionConfiguration]
-        if isinstance(_revision, Unset):
-            revision = UNSET
-        else:
-            revision = RevisionConfiguration.from_dict(_revision)
-
-        _runtime = d.pop("runtime", UNSET)
-        runtime: Union[Unset, Runtime]
-        if isinstance(_runtime, Unset):
-            runtime = UNSET
-        else:
-            runtime = Runtime.from_dict(_runtime)
-
-        sandbox = d.pop("sandbox", UNSET)
-
         _lifecycle = d.pop("lifecycle", UNSET)
         lifecycle: Union[Unset, SandboxLifecycle]
         if isinstance(_lifecycle, Unset):
@@ -214,6 +112,13 @@ class SandboxSpec:
 
         region = d.pop("region", UNSET)
 
+        _runtime = d.pop("runtime", UNSET)
+        runtime: Union[Unset, SandboxRuntime]
+        if isinstance(_runtime, Unset):
+            runtime = UNSET
+        else:
+            runtime = SandboxRuntime.from_dict(_runtime)
+
         volumes = []
         _volumes = d.pop("volumes", UNSET)
         for componentsschemas_volume_attachments_item_data in _volumes or []:
@@ -224,16 +129,10 @@ class SandboxSpec:
             volumes.append(componentsschemas_volume_attachments_item)
 
         sandbox_spec = cls(
-            configurations=configurations,
             enabled=enabled,
-            flavors=flavors,
-            integration_connections=integration_connections,
-            policies=policies,
-            revision=revision,
-            runtime=runtime,
-            sandbox=sandbox,
             lifecycle=lifecycle,
             region=region,
+            runtime=runtime,
             volumes=volumes,
         )
 

blaxel/core/client/models/status.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+
+class Status(str, Enum):
+    BUILDING = "BUILDING"
+    DEACTIVATED = "DEACTIVATED"
+    DEACTIVATING = "DEACTIVATING"
+    DELETING = "DELETING"
+    DEPLOYED = "DEPLOYED"
+    DEPLOYING = "DEPLOYING"
+    FAILED = "FAILED"
+    TERMINATED = "TERMINATED"
+    UPLOADING = "UPLOADING"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "Status | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None

blaxel/core/client/models/template.py

@@ -17,17 +17,18 @@ class Template:
     """Blaxel template
 
     Attributes:
-        default_branch (Union[Unset, str]): Default branch of the template
-        description (Union[Unset, str]): Description of the template
-        download_count (Union[Unset, int]): Number of downloads/clones of the repository
-        forks_count (Union[Unset, int]): Number of forks the repository has
+        default_branch (Union[Unset, str]): Default branch of the template Example: main.
+        description (Union[Unset, str]): Description of the template Example: A starter template for building LangChain
+            agents.
+        download_count (Union[Unset, int]): Number of downloads/clones of the repository Example: 1200.
+        forks_count (Union[Unset, int]): Number of forks the repository has Example: 45.
         icon (Union[Unset, str]): URL to the template's icon
         icon_dark (Union[Unset, str]): URL to the template's icon in dark mode
-        name (Union[Unset, str]): Name of the template
+        name (Union[Unset, str]): Name of the template Example: langchain-agent.
         sha (Union[Unset, str]): SHA of the variable
-        star_count (Union[Unset, int]): Number of stars the repository has
+        star_count (Union[Unset, int]): Number of stars the repository has Example: 150.
         topics (Union[Unset, list[str]]): Topic of the template
-        url (Union[Unset, str]): URL of the template
+        url (Union[Unset, str]): URL of the template Example: https://github.com/blaxel-ai/template-langchain-agent.
         variables (Union[Unset, list['TemplateVariable']]): Variables of the template
     """
 

blaxel/core/client/models/template_variable.py

@@ -13,11 +13,11 @@ class TemplateVariable:
     """Blaxel template variable
 
     Attributes:
-        description (Union[Unset, str]): Description of the variable
-        integration (Union[Unset, str]): Integration of the variable
-        name (Union[Unset, str]): Name of the variable
-        path (Union[Unset, str]): Path of the variable
-        secret (Union[Unset, bool]): Whether the variable is secret
+        description (Union[Unset, str]): Description of the variable Example: OpenAI API key for the agent.
+        integration (Union[Unset, str]): Integration of the variable Example: openai.
+        name (Union[Unset, str]): Name of the variable Example: OPENAI_API_KEY.
+        path (Union[Unset, str]): Path of the variable Example: .env.
+        secret (Union[Unset, bool]): Whether the variable is secret Example: True.
     """
 
     description: Union[Unset, str] = UNSET