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

blaxel/core/client/models/integration_connection.py

@@ -1,10 +1,8 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..types import UNSET, Unset
-
 if TYPE_CHECKING:
     from ..models.integration_connection_spec import IntegrationConnectionSpec
     from ..models.metadata import Metadata
@@ -15,41 +13,39 @@ T = TypeVar("T", bound="IntegrationConnection")
 
 @_attrs_define
 class IntegrationConnection:
-    """Integration Connection
-
-    Attributes:
-        metadata (Union[Unset, Metadata]): Metadata
-        spec (Union[Unset, IntegrationConnectionSpec]): Integration connection specification
+    """Configured connection to an external service (LLM provider, API, SaaS, database) storing credentials and settings
+    for use by workspace resources.
+
+        Attributes:
+            metadata (Metadata): Common metadata fields shared by all Blaxel resources including name, labels, timestamps,
+                and ownership information
+            spec (IntegrationConnectionSpec): Specification defining the integration type, configuration parameters, and
+                encrypted credentials
     """
 
-    metadata: Union[Unset, "Metadata"] = UNSET
-    spec: Union[Unset, "IntegrationConnectionSpec"] = UNSET
+    metadata: "Metadata"
+    spec: "IntegrationConnectionSpec"
     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()
-        elif self.metadata and isinstance(self.metadata, dict):
+        if type(self.metadata) is dict:
             metadata = self.metadata
+        else:
+            metadata = self.metadata.to_dict()
 
-        spec: Union[Unset, dict[str, Any]] = UNSET
-        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
-            spec = self.spec.to_dict()
-        elif self.spec and isinstance(self.spec, dict):
+        if type(self.spec) is dict:
             spec = self.spec
+        else:
+            spec = self.spec.to_dict()
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if metadata is not UNSET:
-            field_dict["metadata"] = metadata
-        if spec is not UNSET:
-            field_dict["spec"] = spec
+        field_dict.update(
+            {
+                "metadata": metadata,
+                "spec": spec,
+            }
+        )
 
         return field_dict
 
@@ -61,19 +57,9 @@ class IntegrationConnection:
         if not src_dict:
             return None
         d = src_dict.copy()
-        _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, Metadata]
-        if isinstance(_metadata, Unset):
-            metadata = UNSET
-        else:
-            metadata = Metadata.from_dict(_metadata)
+        metadata = Metadata.from_dict(d.pop("metadata"))
 
-        _spec = d.pop("spec", UNSET)
-        spec: Union[Unset, IntegrationConnectionSpec]
-        if isinstance(_spec, Unset):
-            spec = UNSET
-        else:
-            spec = IntegrationConnectionSpec.from_dict(_spec)
+        spec = IntegrationConnectionSpec.from_dict(d.pop("spec"))
 
         integration_connection = cls(
             metadata=metadata,

blaxel/core/client/models/integration_connection_spec.py

@@ -15,13 +15,16 @@ T = TypeVar("T", bound="IntegrationConnectionSpec")
 
 @_attrs_define
 class IntegrationConnectionSpec:
-    """Integration connection specification
+    """Specification defining the integration type, configuration parameters, and encrypted credentials
 
     Attributes:
-        config (Union[Unset, IntegrationConnectionSpecConfig]): Additional configuration for the integration
-        integration (Union[Unset, str]): Integration type
-        sandbox (Union[Unset, bool]): Sandbox mode
-        secret (Union[Unset, IntegrationConnectionSpecSecret]): Integration secret
+        config (Union[Unset, IntegrationConnectionSpecConfig]): Non-sensitive configuration parameters for the
+            integration (e.g., organization ID, region)
+        integration (Union[Unset, str]): Integration provider type (e.g., openai, anthropic, github, slack) Example:
+            openai.
+        sandbox (Union[Unset, bool]): Whether this connection uses sandbox/test credentials instead of production
+        secret (Union[Unset, IntegrationConnectionSpecSecret]): Encrypted credentials and API keys for authenticating
+            with the external service
     """
 
     config: Union[Unset, "IntegrationConnectionSpecConfig"] = UNSET

blaxel/core/client/models/integration_connection_spec_config.py

@@ -8,7 +8,7 @@ T = TypeVar("T", bound="IntegrationConnectionSpecConfig")
 
 @_attrs_define
 class IntegrationConnectionSpecConfig:
-    """Additional configuration for the integration"""
+    """Non-sensitive configuration parameters for the integration (e.g., organization ID, region)"""
 
     additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
 

blaxel/core/client/models/integration_connection_spec_secret.py

@@ -8,7 +8,7 @@ T = TypeVar("T", bound="IntegrationConnectionSpecSecret")
 
 @_attrs_define
 class IntegrationConnectionSpecSecret:
-    """Integration secret"""
+    """Encrypted credentials and API keys for authenticating with the external service"""
 
     additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
 

blaxel/core/client/models/integration_endpoint.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,6 +6,8 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
+    from ..models.integration_endpoint_ignore_models_item import IntegrationEndpointIgnoreModelsItem
+    from ..models.integration_endpoint_models_item import IntegrationEndpointModelsItem
     from ..models.integration_endpoint_token import IntegrationEndpointToken
 
 
@@ -18,18 +20,18 @@ class IntegrationEndpoint:
 
     Attributes:
         body (Union[Unset, str]): Integration endpoint body
-        ignore_models (Union[Unset, list[Any]]): Integration endpoint ignore models
+        ignore_models (Union[Unset, list['IntegrationEndpointIgnoreModelsItem']]): Integration endpoint ignore models
         method (Union[Unset, str]): Integration endpoint method
-        models (Union[Unset, list[Any]]): Integration endpoint models
+        models (Union[Unset, list['IntegrationEndpointModelsItem']]): Integration endpoint models
         stream_key (Union[Unset, str]): Integration endpoint stream key
         stream_token (Union[Unset, IntegrationEndpointToken]): Integration endpoint token
         token (Union[Unset, IntegrationEndpointToken]): Integration endpoint token
     """
 
     body: Union[Unset, str] = UNSET
-    ignore_models: Union[Unset, list[Any]] = UNSET
+    ignore_models: Union[Unset, list["IntegrationEndpointIgnoreModelsItem"]] = UNSET
     method: Union[Unset, str] = UNSET
-    models: Union[Unset, list[Any]] = UNSET
+    models: Union[Unset, list["IntegrationEndpointModelsItem"]] = UNSET
     stream_key: Union[Unset, str] = UNSET
     stream_token: Union[Unset, "IntegrationEndpointToken"] = UNSET
     token: Union[Unset, "IntegrationEndpointToken"] = UNSET
@@ -38,15 +40,27 @@ class IntegrationEndpoint:
     def to_dict(self) -> dict[str, Any]:
         body = self.body
 
-        ignore_models: Union[Unset, list[Any]] = UNSET
+        ignore_models: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.ignore_models, Unset):
-            ignore_models = self.ignore_models
+            ignore_models = []
+            for ignore_models_item_data in self.ignore_models:
+                if type(ignore_models_item_data) is dict:
+                    ignore_models_item = ignore_models_item_data
+                else:
+                    ignore_models_item = ignore_models_item_data.to_dict()
+                ignore_models.append(ignore_models_item)
 
         method = self.method
 
-        models: Union[Unset, list[Any]] = UNSET
+        models: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.models, Unset):
-            models = self.models
+            models = []
+            for models_item_data in self.models:
+                if type(models_item_data) is dict:
+                    models_item = models_item_data
+                else:
+                    models_item = models_item_data.to_dict()
+                models.append(models_item)
 
         stream_key = self.stream_key
 
@@ -88,6 +102,10 @@ class IntegrationEndpoint:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        from ..models.integration_endpoint_ignore_models_item import (
+            IntegrationEndpointIgnoreModelsItem,
+        )
+        from ..models.integration_endpoint_models_item import IntegrationEndpointModelsItem
         from ..models.integration_endpoint_token import IntegrationEndpointToken
 
         if not src_dict:
@@ -95,11 +113,23 @@ class IntegrationEndpoint:
         d = src_dict.copy()
         body = d.pop("body", UNSET)
 
-        ignore_models = cast(list[Any], d.pop("ignoreModels", d.pop("ignore_models", UNSET)))
+        ignore_models = []
+        _ignore_models = d.pop("ignoreModels", d.pop("ignore_models", UNSET))
+        for ignore_models_item_data in _ignore_models or []:
+            ignore_models_item = IntegrationEndpointIgnoreModelsItem.from_dict(
+                ignore_models_item_data
+            )
+
+            ignore_models.append(ignore_models_item)
 
         method = d.pop("method", UNSET)
 
-        models = cast(list[Any], d.pop("models", UNSET))
+        models = []
+        _models = d.pop("models", UNSET)
+        for models_item_data in _models or []:
+            models_item = IntegrationEndpointModelsItem.from_dict(models_item_data)
+
+            models.append(models_item)
 
         stream_key = d.pop("streamKey", d.pop("stream_key", UNSET))
 

blaxel/core/client/models/integration_endpoint_ignore_models_item.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="IntegrationEndpointIgnoreModelsItem")
+
+
+@_attrs_define
+class IntegrationEndpointIgnoreModelsItem:
+    """ """
+
+    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()
+        integration_endpoint_ignore_models_item = cls()
+
+        integration_endpoint_ignore_models_item.additional_properties = d
+        return integration_endpoint_ignore_models_item
+
+    @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/{mcp_definition_entrypoint.py → integration_endpoint_models_item.py}

@@ -3,12 +3,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="MCPDefinitionEntrypoint")
+T = TypeVar("T", bound="IntegrationEndpointModelsItem")
 
 
 @_attrs_define
-class MCPDefinitionEntrypoint:
-    """Entrypoint of the artifact"""
+class IntegrationEndpointModelsItem:
+    """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -23,10 +23,10 @@ class MCPDefinitionEntrypoint:
         if not src_dict:
             return None
         d = src_dict.copy()
-        mcp_definition_entrypoint = cls()
+        integration_endpoint_models_item = cls()
 
-        mcp_definition_entrypoint.additional_properties = d
-        return mcp_definition_entrypoint
+        integration_endpoint_models_item.additional_properties = d
+        return integration_endpoint_models_item
 
     @property
     def additional_keys(self) -> list[str]:

blaxel/core/client/models/job.py

@@ -3,6 +3,7 @@ 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:
@@ -16,22 +17,35 @@ T = TypeVar("T", bound="Job")
 
 @_attrs_define
 class Job:
-    """Job
-
-    Attributes:
-        events (Union[Unset, list['CoreEvent']]): Core events
-        metadata (Union[Unset, Metadata]): Metadata
-        spec (Union[Unset, JobSpec]): Job specification
-        status (Union[Unset, str]): Job status
+    """Batch processing job definition for running parallel AI tasks. Jobs can execute multiple tasks concurrently with
+    configurable parallelism, retries, and timeouts.
+
+        Attributes:
+            metadata (Metadata): Common metadata fields shared by all Blaxel resources including name, labels, timestamps,
+                and ownership information
+            spec (JobSpec): Configuration for a batch job including execution parameters, parallelism settings, and
+                deployment region
+            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: "Metadata"
+    spec: "JobSpec"
     events: Union[Unset, list["CoreEvent"]] = UNSET
-    metadata: Union[Unset, "Metadata"] = UNSET
-    spec: Union[Unset, "JobSpec"] = UNSET
-    status: Union[Unset, str] = UNSET
+    status: Union[Unset, Status] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        if type(self.metadata) is dict:
+            metadata = self.metadata
+        else:
+            metadata = self.metadata.to_dict()
+
+        if type(self.spec) is dict:
+            spec = self.spec
+        else:
+            spec = self.spec.to_dict()
+
         events: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.events, Unset):
             events = []
@@ -44,33 +58,20 @@ class Job:
                     )
                 events.append(componentsschemas_core_events_item)
 
-        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()
-        elif self.metadata and isinstance(self.metadata, dict):
-            metadata = self.metadata
-
-        spec: Union[Unset, dict[str, Any]] = UNSET
-        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
-            spec = self.spec.to_dict()
-        elif self.spec and isinstance(self.spec, dict):
-            spec = self.spec
-
-        status = self.status
+        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({})
+        field_dict.update(
+            {
+                "metadata": metadata,
+                "spec": spec,
+            }
+        )
         if events is not UNSET:
             field_dict["events"] = events
-        if metadata is not UNSET:
-            field_dict["metadata"] = metadata
-        if spec is not UNSET:
-            field_dict["spec"] = spec
         if status is not UNSET:
             field_dict["status"] = status
 
@@ -85,6 +86,10 @@ class Job:
         if not src_dict:
             return None
         d = src_dict.copy()
+        metadata = Metadata.from_dict(d.pop("metadata"))
+
+        spec = JobSpec.from_dict(d.pop("spec"))
+
         events = []
         _events = d.pop("events", UNSET)
         for componentsschemas_core_events_item_data in _events or []:
@@ -94,26 +99,17 @@ class Job:
 
             events.append(componentsschemas_core_events_item)
 
-        _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, Metadata]
-        if isinstance(_metadata, Unset):
-            metadata = UNSET
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, Status]
+        if isinstance(_status, Unset):
+            status = UNSET
         else:
-            metadata = Metadata.from_dict(_metadata)
-
-        _spec = d.pop("spec", UNSET)
-        spec: Union[Unset, JobSpec]
-        if isinstance(_spec, Unset):
-            spec = UNSET
-        else:
-            spec = JobSpec.from_dict(_spec)
-
-        status = d.pop("status", UNSET)
+            status = Status(_status)
 
         job = cls(
-            events=events,
             metadata=metadata,
             spec=spec,
+            events=events,
             status=status,
         )
 

blaxel/core/client/models/job_execution.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.job_execution_status import JobExecutionStatus
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
@@ -20,36 +21,30 @@ class JobExecution:
     """Job execution
 
     Attributes:
-        metadata (Union[Unset, JobExecutionMetadata]): Job execution metadata
-        spec (Union[Unset, JobExecutionSpec]): Job execution specification
+        metadata (JobExecutionMetadata): Job execution metadata
+        spec (JobExecutionSpec): Job execution specification
         stats (Union[Unset, JobExecutionStats]): Job execution statistics
-        status (Union[Unset, str]): Job execution status
+        status (Union[Unset, JobExecutionStatus]): Job execution status
         tasks (Union[Unset, list['JobExecutionTask']]): List of execution tasks
     """
 
-    metadata: Union[Unset, "JobExecutionMetadata"] = UNSET
-    spec: Union[Unset, "JobExecutionSpec"] = UNSET
+    metadata: "JobExecutionMetadata"
+    spec: "JobExecutionSpec"
     stats: Union[Unset, "JobExecutionStats"] = UNSET
-    status: Union[Unset, str] = UNSET
+    status: Union[Unset, JobExecutionStatus] = UNSET
     tasks: Union[Unset, list["JobExecutionTask"]] = UNSET
     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()
-        elif self.metadata and isinstance(self.metadata, dict):
+        if type(self.metadata) is dict:
             metadata = self.metadata
+        else:
+            metadata = self.metadata.to_dict()
 
-        spec: Union[Unset, dict[str, Any]] = UNSET
-        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
-            spec = self.spec.to_dict()
-        elif self.spec and isinstance(self.spec, dict):
+        if type(self.spec) is dict:
             spec = self.spec
+        else:
+            spec = self.spec.to_dict()
 
         stats: Union[Unset, dict[str, Any]] = UNSET
         if self.stats and not isinstance(self.stats, Unset) and not isinstance(self.stats, dict):
@@ -57,7 +52,9 @@ class JobExecution:
         elif self.stats and isinstance(self.stats, dict):
             stats = self.stats
 
-        status = self.status
+        status: Union[Unset, str] = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
 
         tasks: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.tasks, Unset):
@@ -71,11 +68,12 @@ class JobExecution:
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if metadata is not UNSET:
-            field_dict["metadata"] = metadata
-        if spec is not UNSET:
-            field_dict["spec"] = spec
+        field_dict.update(
+            {
+                "metadata": metadata,
+                "spec": spec,
+            }
+        )
         if stats is not UNSET:
             field_dict["stats"] = stats
         if status is not UNSET:
@@ -95,19 +93,9 @@ class JobExecution:
         if not src_dict:
             return None
         d = src_dict.copy()
-        _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, JobExecutionMetadata]
-        if isinstance(_metadata, Unset):
-            metadata = UNSET
-        else:
-            metadata = JobExecutionMetadata.from_dict(_metadata)
+        metadata = JobExecutionMetadata.from_dict(d.pop("metadata"))
 
-        _spec = d.pop("spec", UNSET)
-        spec: Union[Unset, JobExecutionSpec]
-        if isinstance(_spec, Unset):
-            spec = UNSET
-        else:
-            spec = JobExecutionSpec.from_dict(_spec)
+        spec = JobExecutionSpec.from_dict(d.pop("spec"))
 
         _stats = d.pop("stats", UNSET)
         stats: Union[Unset, JobExecutionStats]
@@ -116,7 +104,12 @@ class JobExecution:
         else:
             stats = JobExecutionStats.from_dict(_stats)
 
-        status = d.pop("status", UNSET)
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, JobExecutionStatus]
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = JobExecutionStatus(_status)
 
         tasks = []
         _tasks = d.pop("tasks", UNSET)

blaxel/core/client/models/job_execution_metadata.py

@@ -18,11 +18,11 @@ class JobExecutionMetadata:
         created_at (Union[Unset, str]): Creation timestamp
         deleted_at (Union[Unset, str]): Deletion timestamp
         expired_at (Union[Unset, str]): Expiration timestamp
-        id (Union[Unset, str]): Execution ID
-        job (Union[Unset, str]): Job name
+        id (Union[Unset, str]): Execution ID Example: exec-abc123.
+        job (Union[Unset, str]): Job name Example: data-processing-job.
         started_at (Union[Unset, str]): Start timestamp
         updated_at (Union[Unset, str]): Last update timestamp
-        workspace (Union[Unset, str]): Workspace ID
+        workspace (Union[Unset, str]): Workspace ID Example: my-workspace.
     """
 
     cluster: Union[Unset, str] = UNSET

blaxel/core/client/models/job_execution_spec.py

@@ -17,9 +17,9 @@ class JobExecutionSpec:
     """Job execution specification
 
     Attributes:
-        parallelism (Union[Unset, int]): Number of parallel tasks
+        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)
+        timeout (Union[Unset, int]): Job timeout in seconds (captured at execution creation time) Example: 3600.
     """
 
     parallelism: Union[Unset, int] = UNSET

blaxel/core/client/models/job_execution_stats.py

@@ -14,11 +14,11 @@ class JobExecutionStats:
 
     Attributes:
         cancelled (Union[Unset, int]): Number of cancelled tasks
-        failure (Union[Unset, int]): Number of failed tasks
-        retried (Union[Unset, int]): Number of retried tasks
-        running (Union[Unset, int]): Number of running tasks
-        success (Union[Unset, int]): Number of successful tasks
-        total (Union[Unset, int]): Total number of tasks
+        failure (Union[Unset, int]): Number of failed tasks Example: 1.
+        retried (Union[Unset, int]): Number of retried tasks Example: 2.
+        running (Union[Unset, int]): Number of running tasks Example: 1.
+        success (Union[Unset, int]): Number of successful tasks Example: 8.
+        total (Union[Unset, int]): Total number of tasks Example: 10.
     """
 
     cancelled: Union[Unset, int] = UNSET

blaxel/core/client/models/job_execution_status.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+
+class JobExecutionStatus(str, Enum):
+    CANCELLED = "cancelled"
+    CANCELLING = "cancelling"
+    FAILED = "failed"
+    PENDING = "pending"
+    QUEUED = "queued"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    TIMEOUT = "timeout"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "JobExecutionStatus | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None