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

blaxel/core/client/models/job_execution_task.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_task_status import JobExecutionTaskStatus
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
@@ -22,13 +23,13 @@ class JobExecutionTask:
         conditions (Union[Unset, list['JobExecutionTaskCondition']]): Task conditions
         metadata (Union[Unset, JobExecutionTaskMetadata]): Job execution task metadata
         spec (Union[Unset, JobExecutionTaskSpec]): Job execution task specification
-        status (Union[Unset, str]): Job execution task status
+        status (Union[Unset, JobExecutionTaskStatus]): Job execution task status
     """
 
     conditions: Union[Unset, list["JobExecutionTaskCondition"]] = UNSET
     metadata: Union[Unset, "JobExecutionTaskMetadata"] = UNSET
     spec: Union[Unset, "JobExecutionTaskSpec"] = UNSET
-    status: Union[Unset, str] = UNSET
+    status: Union[Unset, JobExecutionTaskStatus] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -58,7 +59,9 @@ class JobExecutionTask:
         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)
@@ -104,7 +107,12 @@ class JobExecutionTask:
         else:
             spec = JobExecutionTaskSpec.from_dict(_spec)
 
-        status = d.pop("status", UNSET)
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, JobExecutionTaskStatus]
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = JobExecutionTaskStatus(_status)
 
         job_execution_task = cls(
             conditions=conditions,

blaxel/core/client/models/job_execution_task_metadata.py

@@ -15,7 +15,7 @@ class JobExecutionTaskMetadata:
     Attributes:
         completed_at (Union[Unset, str]): Completion timestamp
         created_at (Union[Unset, str]): Creation timestamp
-        name (Union[Unset, str]): Task name
+        name (Union[Unset, str]): Task name Example: task-0.
         scheduled_at (Union[Unset, str]): Scheduled timestamp
         started_at (Union[Unset, str]): Start timestamp
         updated_at (Union[Unset, str]): Last update timestamp

blaxel/core/client/models/job_execution_task_spec.py

@@ -13,8 +13,8 @@ class JobExecutionTaskSpec:
     """Job execution task specification
 
     Attributes:
-        max_retries (Union[Unset, int]): Maximum number of retries
-        timeout (Union[Unset, str]): Task timeout duration
+        max_retries (Union[Unset, int]): Maximum number of retries Example: 3.
+        timeout (Union[Unset, str]): Task timeout duration Example: 30m.
     """
 
     max_retries: Union[Unset, int] = UNSET

blaxel/core/client/models/job_execution_task_status.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class JobExecutionTaskStatus(str, Enum):
+    CANCELLED = "cancelled"
+    FAILED = "failed"
+    PENDING = "pending"
+    RECONCILING = "reconciling"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    UNSPECIFIED = "unspecified"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "JobExecutionTaskStatus | 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/job_runtime.py

@@ -0,0 +1,172 @@
+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_runtime_generation import JobRuntimeGeneration
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.env import Env
+    from ..models.port import Port
+
+
+T = TypeVar("T", bound="JobRuntime")
+
+
+@_attrs_define
+class JobRuntime:
+    """Runtime configuration defining how batch job tasks are executed with parallelism and retry settings
+
+    Attributes:
+        envs (Union[Unset, list['Env']]): Environment variables injected into job tasks. Supports Kubernetes EnvVar
+            format with valueFrom references.
+        generation (Union[Unset, JobRuntimeGeneration]): Infrastructure generation: mk2 (containers, 2-10s cold starts)
+            or mk3 (microVMs, sub-25ms cold starts) Example: mk3.
+        image (Union[Unset, str]): Container image built by Blaxel when deploying with 'bl deploy'. This field is auto-
+            populated during deployment.
+        max_concurrent_tasks (Union[Unset, int]): Maximum number of tasks that can run simultaneously within a single
+            execution Example: 10.
+        max_retries (Union[Unset, int]): Number of automatic retry attempts for failed tasks before marking as failed
+            Example: 3.
+        memory (Union[Unset, int]): Memory allocation in megabytes. Also determines CPU allocation (CPU cores = memory
+            in MB / 2048, e.g., 4096MB = 2 CPUs). Example: 2048.
+        ports (Union[Unset, list['Port']]): Set of ports for a resource
+        timeout (Union[Unset, int]): Maximum execution time in seconds before a task is terminated Example: 3600.
+    """
+
+    envs: Union[Unset, list["Env"]] = UNSET
+    generation: Union[Unset, JobRuntimeGeneration] = UNSET
+    image: Union[Unset, str] = UNSET
+    max_concurrent_tasks: Union[Unset, int] = UNSET
+    max_retries: Union[Unset, int] = UNSET
+    memory: Union[Unset, int] = UNSET
+    ports: Union[Unset, list["Port"]] = UNSET
+    timeout: Union[Unset, int] = 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)
+
+        generation: Union[Unset, str] = UNSET
+        if not isinstance(self.generation, Unset):
+            generation = self.generation.value
+
+        image = self.image
+
+        max_concurrent_tasks = self.max_concurrent_tasks
+
+        max_retries = self.max_retries
+
+        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)
+
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if envs is not UNSET:
+            field_dict["envs"] = envs
+        if generation is not UNSET:
+            field_dict["generation"] = generation
+        if image is not UNSET:
+            field_dict["image"] = image
+        if max_concurrent_tasks is not UNSET:
+            field_dict["maxConcurrentTasks"] = max_concurrent_tasks
+        if max_retries is not UNSET:
+            field_dict["maxRetries"] = max_retries
+        if memory is not UNSET:
+            field_dict["memory"] = memory
+        if ports is not UNSET:
+            field_dict["ports"] = ports
+        if timeout is not UNSET:
+            field_dict["timeout"] = timeout
+
+        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)
+
+        _generation = d.pop("generation", UNSET)
+        generation: Union[Unset, JobRuntimeGeneration]
+        if isinstance(_generation, Unset):
+            generation = UNSET
+        else:
+            generation = JobRuntimeGeneration(_generation)
+
+        image = d.pop("image", UNSET)
+
+        max_concurrent_tasks = d.pop("maxConcurrentTasks", d.pop("max_concurrent_tasks", UNSET))
+
+        max_retries = d.pop("maxRetries", d.pop("max_retries", 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)
+
+        timeout = d.pop("timeout", UNSET)
+
+        job_runtime = cls(
+            envs=envs,
+            generation=generation,
+            image=image,
+            max_concurrent_tasks=max_concurrent_tasks,
+            max_retries=max_retries,
+            memory=memory,
+            ports=ports,
+            timeout=timeout,
+        )
+
+        job_runtime.additional_properties = d
+        return job_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/job_runtime_generation.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class JobRuntimeGeneration(str, Enum):
+    MK2 = "mk2"
+    MK3 = "mk3"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "JobRuntimeGeneration | 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/job_spec.py

@@ -6,10 +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.job_runtime import JobRuntime
     from ..models.revision_configuration import RevisionConfiguration
-    from ..models.runtime import Runtime
     from ..models.trigger import Trigger
 
 
@@ -18,64 +16,36 @@ T = TypeVar("T", bound="JobSpec")
 
 @_attrs_define
 class JobSpec:
-    """Job specification
+    """Configuration for a batch job including execution parameters, parallelism settings, and deployment region
 
     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]]):
+        enabled (Union[Unset, bool]): When false, the job is disabled and new executions cannot be triggered Default:
+            True. Example: True.
         policies (Union[Unset, list[str]]):
+        region (Union[Unset, str]): Region where the job should be created (e.g. us-was-1, eu-lon-1) Example: us-was-1.
         revision (Union[Unset, RevisionConfiguration]): Revision configuration
-        runtime (Union[Unset, Runtime]): Set of configurations for a deployment
-        sandbox (Union[Unset, bool]): Sandbox mode
-        region (Union[Unset, str]): Region where the job should be created (e.g. us-was-1, eu-lon-1)
+        runtime (Union[Unset, JobRuntime]): Runtime configuration defining how batch job tasks are executed with
+            parallelism and retry settings
         triggers (Union[Unset, list['Trigger']]): Triggers to use your agent
     """
 
-    configurations: Union[Unset, "CoreSpecConfigurations"] = UNSET
-    enabled: Union[Unset, bool] = UNSET
-    flavors: Union[Unset, list["Flavor"]] = UNSET
-    integration_connections: Union[Unset, list[str]] = UNSET
+    enabled: Union[Unset, bool] = True
     policies: Union[Unset, list[str]] = UNSET
-    revision: Union[Unset, "RevisionConfiguration"] = UNSET
-    runtime: Union[Unset, "Runtime"] = UNSET
-    sandbox: Union[Unset, bool] = UNSET
     region: Union[Unset, str] = UNSET
+    revision: Union[Unset, "RevisionConfiguration"] = UNSET
+    runtime: Union[Unset, "JobRuntime"] = UNSET
     triggers: Union[Unset, list["Trigger"]] = 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
 
+        region = self.region
+
         revision: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.revision
@@ -96,10 +66,6 @@ class JobSpec:
         elif self.runtime and isinstance(self.runtime, dict):
             runtime = self.runtime
 
-        sandbox = self.sandbox
-
-        region = self.region
-
         triggers: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.triggers, Unset):
             triggers = []
@@ -113,24 +79,16 @@ class JobSpec:
         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 region is not UNSET:
+            field_dict["region"] = region
         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 region is not UNSET:
-            field_dict["region"] = region
         if triggers is not UNSET:
             field_dict["triggers"] = triggers
 
@@ -138,37 +96,19 @@ class JobSpec:
 
     @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.job_runtime import JobRuntime
         from ..models.revision_configuration import RevisionConfiguration
-        from ..models.runtime import Runtime
         from ..models.trigger import Trigger
 
         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))
 
+        region = d.pop("region", UNSET)
+
         _revision = d.pop("revision", UNSET)
         revision: Union[Unset, RevisionConfiguration]
         if isinstance(_revision, Unset):
@@ -177,15 +117,11 @@ class JobSpec:
             revision = RevisionConfiguration.from_dict(_revision)
 
         _runtime = d.pop("runtime", UNSET)
-        runtime: Union[Unset, Runtime]
+        runtime: Union[Unset, JobRuntime]
         if isinstance(_runtime, Unset):
             runtime = UNSET
         else:
-            runtime = Runtime.from_dict(_runtime)
-
-        sandbox = d.pop("sandbox", UNSET)
-
-        region = d.pop("region", UNSET)
+            runtime = JobRuntime.from_dict(_runtime)
 
         triggers = []
         _triggers = d.pop("triggers", UNSET)
@@ -197,15 +133,11 @@ class JobSpec:
             triggers.append(componentsschemas_triggers_item)
 
         job_spec = cls(
-            configurations=configurations,
             enabled=enabled,
-            flavors=flavors,
-            integration_connections=integration_connections,
             policies=policies,
+            region=region,
             revision=revision,
             runtime=runtime,
-            sandbox=sandbox,
-            region=region,
             triggers=triggers,
         )
 

blaxel/core/client/models/location_response.py

@@ -17,12 +17,12 @@ class LocationResponse:
     """Location availability for policies
 
     Attributes:
-        continent (Union[Unset, str]): Continent of the location
-        country (Union[Unset, str]): Country of the location
+        continent (Union[Unset, str]): Continent of the location Example: NA.
+        country (Union[Unset, str]): Country of the location Example: US.
         flavors (Union[Unset, list['Flavor']]): Hardware flavors available in the location
-        location (Union[Unset, str]): Name of the location
-        region (Union[Unset, str]): Region of the location
-        status (Union[Unset, str]): Status of the location
+        location (Union[Unset, str]): Name of the location Example: Portland.
+        region (Union[Unset, str]): Region of the location Example: us-pdx-1.
+        status (Union[Unset, str]): Status of the location Example: healthy.
     """
 
     continent: Union[Unset, str] = UNSET

blaxel/core/client/models/mcp_definition.py

@@ -6,8 +6,9 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.mcp_definition_entrypoint import MCPDefinitionEntrypoint
-    from ..models.mcp_definition_form import MCPDefinitionForm
+    from ..models.entrypoint import Entrypoint
+    from ..models.form import Form
+    from ..models.mcp_definition_categories_item import MCPDefinitionCategoriesItem
 
 
 T = TypeVar("T", bound="MCPDefinition")
@@ -20,13 +21,13 @@ class MCPDefinition:
     Attributes:
         created_at (Union[Unset, str]): The date and time when the resource was created
         updated_at (Union[Unset, str]): The date and time when the resource was updated
-        categories (Union[Unset, list[Any]]): Categories of the artifact
+        categories (Union[Unset, list['MCPDefinitionCategoriesItem']]): Categories of the artifact
         coming_soon (Union[Unset, bool]): If the artifact is coming soon
         description (Union[Unset, str]): Description of the artifact
         display_name (Union[Unset, str]): Display name of the artifact
         enterprise (Union[Unset, bool]): If the artifact is enterprise
-        entrypoint (Union[Unset, MCPDefinitionEntrypoint]): Entrypoint of the artifact
-        form (Union[Unset, MCPDefinitionForm]): Form of the artifact
+        entrypoint (Union[Unset, Entrypoint]): Entrypoint of the artifact
+        form (Union[Unset, Form]): Form of the artifact
         hidden (Union[Unset, bool]): If the artifact is hidden
         hidden_secrets (Union[Unset, list[str]]): Hidden secrets of the artifact
         icon (Union[Unset, str]): Icon of the artifact
@@ -40,13 +41,13 @@ class MCPDefinition:
 
     created_at: Union[Unset, str] = UNSET
     updated_at: Union[Unset, str] = UNSET
-    categories: Union[Unset, list[Any]] = UNSET
+    categories: Union[Unset, list["MCPDefinitionCategoriesItem"]] = UNSET
     coming_soon: Union[Unset, bool] = UNSET
     description: Union[Unset, str] = UNSET
     display_name: Union[Unset, str] = UNSET
     enterprise: Union[Unset, bool] = UNSET
-    entrypoint: Union[Unset, "MCPDefinitionEntrypoint"] = UNSET
-    form: Union[Unset, "MCPDefinitionForm"] = UNSET
+    entrypoint: Union[Unset, "Entrypoint"] = UNSET
+    form: Union[Unset, "Form"] = UNSET
     hidden: Union[Unset, bool] = UNSET
     hidden_secrets: Union[Unset, list[str]] = UNSET
     icon: Union[Unset, str] = UNSET
@@ -63,9 +64,15 @@ class MCPDefinition:
 
         updated_at = self.updated_at
 
-        categories: Union[Unset, list[Any]] = UNSET
+        categories: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.categories, Unset):
-            categories = self.categories
+            categories = []
+            for categories_item_data in self.categories:
+                if type(categories_item_data) is dict:
+                    categories_item = categories_item_data
+                else:
+                    categories_item = categories_item_data.to_dict()
+                categories.append(categories_item)
 
         coming_soon = self.coming_soon
 
@@ -155,8 +162,9 @@ class MCPDefinition:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.mcp_definition_entrypoint import MCPDefinitionEntrypoint
-        from ..models.mcp_definition_form import MCPDefinitionForm
+        from ..models.entrypoint import Entrypoint
+        from ..models.form import Form
+        from ..models.mcp_definition_categories_item import MCPDefinitionCategoriesItem
 
         if not src_dict:
             return None
@@ -165,7 +173,12 @@ class MCPDefinition:
 
         updated_at = d.pop("updatedAt", d.pop("updated_at", UNSET))
 
-        categories = cast(list[Any], d.pop("categories", UNSET))
+        categories = []
+        _categories = d.pop("categories", UNSET)
+        for categories_item_data in _categories or []:
+            categories_item = MCPDefinitionCategoriesItem.from_dict(categories_item_data)
+
+            categories.append(categories_item)
 
         coming_soon = d.pop("coming_soon", UNSET)
 
@@ -176,18 +189,18 @@ class MCPDefinition:
         enterprise = d.pop("enterprise", UNSET)
 
         _entrypoint = d.pop("entrypoint", UNSET)
-        entrypoint: Union[Unset, MCPDefinitionEntrypoint]
+        entrypoint: Union[Unset, Entrypoint]
         if isinstance(_entrypoint, Unset):
             entrypoint = UNSET
         else:
-            entrypoint = MCPDefinitionEntrypoint.from_dict(_entrypoint)
+            entrypoint = Entrypoint.from_dict(_entrypoint)
 
         _form = d.pop("form", UNSET)
-        form: Union[Unset, MCPDefinitionForm]
+        form: Union[Unset, Form]
         if isinstance(_form, Unset):
             form = UNSET
         else:
-            form = MCPDefinitionForm.from_dict(_form)
+            form = Form.from_dict(_form)
 
         hidden = d.pop("hidden", UNSET)
 

blaxel/core/client/models/{job_metrics_tasks_total.py → mcp_definition_categories_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="JobMetricsTasksTotal")
+T = TypeVar("T", bound="MCPDefinitionCategoriesItem")
 
 
 @_attrs_define
-class JobMetricsTasksTotal:
-    """Total tasks"""
+class MCPDefinitionCategoriesItem:
+    """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -23,10 +23,10 @@ class JobMetricsTasksTotal:
         if not src_dict:
             return None
         d = src_dict.copy()
-        job_metrics_tasks_total = cls()
+        mcp_definition_categories_item = cls()
 
-        job_metrics_tasks_total.additional_properties = d
-        return job_metrics_tasks_total
+        mcp_definition_categories_item.additional_properties = d
+        return mcp_definition_categories_item
 
     @property
     def additional_keys(self) -> list[str]: