dstack 0.19.7__py3-none-any.whl → 0.19.8__py3-none-any.whl

dstack/_internal/server/services/fleets.py

@@ -1,5 +1,3 @@
-import random
-import string
 import uuid
 from datetime import datetime, timezone
 from typing import List, Literal, Optional, Tuple, Union, cast
@@ -33,6 +31,7 @@ from dstack._internal.core.models.instances import (
     SSHConnectionParams,
     SSHKey,
 )
+from dstack._internal.core.models.placement import PlacementGroup
 from dstack._internal.core.models.profiles import (
     Profile,
     SpotPolicy,
@@ -62,6 +61,7 @@ from dstack._internal.server.services.projects import (
     list_project_models,
     list_user_project_models,
 )
+from dstack._internal.server.services.resources import set_resources_defaults
 from dstack._internal.utils import random_names
 from dstack._internal.utils.logging import get_logger
 from dstack._internal.utils.ssh import pkey_from_str
@@ -243,6 +243,7 @@ async def get_plan(
         spec=effective_spec,
     )
     effective_spec = FleetSpec.parse_obj(effective_spec.dict())
+    _validate_fleet_spec_and_set_defaults(spec)
     current_fleet: Optional[Fleet] = None
     current_fleet_id: Optional[uuid.UUID] = None
     if effective_spec.configuration.name is not None:
@@ -282,6 +283,7 @@ async def get_create_instance_offers(
     project: ProjectModel,
     profile: Profile,
     requirements: Requirements,
+    placement_group: Optional[PlacementGroup] = None,
     fleet_spec: Optional[FleetSpec] = None,
     fleet_model: Optional[FleetModel] = None,
     blocks: Union[int, Literal["auto"]] = 1,
@@ -307,6 +309,7 @@ async def get_create_instance_offers(
         exclude_not_available=exclude_not_available,
         multinode=multinode,
         master_job_provisioning_data=master_job_provisioning_data,
+        placement_group=placement_group,
         blocks=blocks,
     )
     offers = [
@@ -345,7 +348,7 @@ async def create_fleet(
         spec=spec,
     )
     spec = FleetSpec.parse_obj(spec.dict())
-    _validate_fleet_spec(spec)
+    _validate_fleet_spec_and_set_defaults(spec)
 
     if spec.configuration.ssh_config is not None:
         _check_can_manage_ssh_fleets(user=user, project=project)
@@ -393,17 +396,12 @@ async def create_fleet(
                 )
                 fleet_model.instances.append(instances_model)
         else:
-            placement_group_name = _get_placement_group_name(
-                project=project,
-                fleet_spec=spec,
-            )
             for i in range(_get_fleet_nodes_to_provision(spec)):
                 instance_model = await create_fleet_instance_model(
                     session=session,
                     project=project,
                     user=user,
                     spec=spec,
-                    placement_group_name=placement_group_name,
                     reservation=spec.configuration.reservation,
                     instance_num=i,
                 )
@@ -417,7 +415,6 @@ async def create_fleet_instance_model(
     project: ProjectModel,
     user: UserModel,
     spec: FleetSpec,
-    placement_group_name: Optional[str],
     reservation: Optional[str],
     instance_num: int,
 ) -> InstanceModel:
@@ -431,7 +428,6 @@ async def create_fleet_instance_model(
         requirements=requirements,
         instance_name=f"{spec.configuration.name}-{instance_num}",
         instance_num=instance_num,
-        placement_group_name=placement_group_name,
         reservation=reservation,
         blocks=spec.configuration.blocks,
         tags=spec.configuration.tags,
@@ -652,7 +648,7 @@ def _remove_fleet_spec_sensitive_info(spec: FleetSpec):
                 host.ssh_key = None
 
 
-def _validate_fleet_spec(spec: FleetSpec):
+def _validate_fleet_spec_and_set_defaults(spec: FleetSpec):
     if spec.configuration.name is not None:
         validate_dstack_resource_name(spec.configuration.name)
     if spec.configuration.ssh_config is None and spec.configuration.nodes is None:
@@ -665,6 +661,8 @@ def _validate_fleet_spec(spec: FleetSpec):
             if isinstance(host, SSHHostParams) and host.ssh_key is not None:
                 _validate_ssh_key(host.ssh_key)
         _validate_internal_ips(spec.configuration.ssh_config)
+    if spec.configuration.resources is not None:
+        set_resources_defaults(spec.configuration.resources)
 
 
 def _validate_all_ssh_params_specified(ssh_config: SSHParams):
@@ -735,18 +733,3 @@ def _get_fleet_requirements(fleet_spec: FleetSpec) -> Requirements:
         reservation=fleet_spec.configuration.reservation,
     )
     return requirements
-
-
-def _get_placement_group_name(
-    project: ProjectModel,
-    fleet_spec: FleetSpec,
-) -> Optional[str]:
-    if fleet_spec.configuration.placement != InstanceGroupPlacement.CLUSTER:
-        return None
-    # A random suffix to avoid clashing with to-be-deleted placement groups left by old fleets
-    suffix = _generate_random_placement_group_suffix()
-    return f"{project.name}-{fleet_spec.configuration.name}-{suffix}-pg"
-
-
-def _generate_random_placement_group_suffix(length: int = 8) -> str:
-    return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(length))

dstack/_internal/server/services/instances.py

@@ -408,7 +408,6 @@ async def create_instance_model(
     requirements: Requirements,
     instance_name: str,
     instance_num: int,
-    placement_group_name: Optional[str],
     reservation: Optional[str],
     blocks: Union[Literal["auto"], int],
     tags: Optional[Dict[str, str]],
@@ -427,7 +426,6 @@ async def create_instance_model(
         user=user.name,
         ssh_keys=[project_ssh_key],
         instance_id=str(instance_id),
-        placement_group_name=placement_group_name,
         reservation=reservation,
         tags=tags,
     )

dstack/_internal/server/services/offers.py

@@ -8,12 +8,14 @@ from dstack._internal.core.backends import (
     BACKENDS_WITH_RESERVATION_SUPPORT,
 )
 from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.base.compute import ComputeWithPlacementGroupSupport
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.instances import (
     InstanceOfferWithAvailability,
     InstanceType,
     Resources,
 )
+from dstack._internal.core.models.placement import PlacementGroup
 from dstack._internal.core.models.profiles import Profile
 from dstack._internal.core.models.runs import JobProvisioningData, Requirements
 from dstack._internal.core.models.volumes import Volume
@@ -31,6 +33,7 @@ async def get_offers_by_requirements(
     volumes: Optional[List[List[Volume]]] = None,
     privileged: bool = False,
     instance_mounts: bool = False,
+    placement_group: Optional[PlacementGroup] = None,
     blocks: Union[int, Literal["auto"]] = 1,
 ) -> List[Tuple[Backend, InstanceOfferWithAvailability]]:
     backends: List[Backend] = await backends_services.get_project_backends(project=project)
@@ -116,6 +119,18 @@ async def get_offers_by_requirements(
                     new_offers.append((b, new_offer))
         offers = new_offers
 
+    if placement_group is not None:
+        new_offers = []
+        for b, o in offers:
+            for backend in backends:
+                compute = backend.compute()
+                if isinstance(
+                    compute, ComputeWithPlacementGroupSupport
+                ) and compute.is_suitable_placement_group(placement_group, o):
+                    new_offers.append((b, o))
+                    break
+        offers = new_offers
+
     if profile.instance_types is not None:
         instance_types = [i.lower() for i in profile.instance_types]
         offers = [(b, o) for b, o in offers if o.instance.name.lower() in instance_types]

dstack/_internal/server/services/placement.py

@@ -1,8 +1,9 @@
+from collections.abc import Iterable
 from typing import Optional
 from uuid import UUID
 
 from git import List
-from sqlalchemy import select
+from sqlalchemy import and_, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from dstack._internal.core.models.placement import (
@@ -13,15 +14,35 @@ from dstack._internal.core.models.placement import (
 from dstack._internal.server.models import PlacementGroupModel
 
 
-async def get_fleet_placement_groups(
+async def get_fleet_placement_group_models(
     session: AsyncSession,
     fleet_id: UUID,
-) -> List[PlacementGroup]:
+) -> List[PlacementGroupModel]:
     res = await session.execute(
-        select(PlacementGroupModel).where(PlacementGroupModel.fleet_id == fleet_id)
+        select(PlacementGroupModel).where(
+            and_(
+                PlacementGroupModel.fleet_id == fleet_id,
+                PlacementGroupModel.deleted == False,
+                PlacementGroupModel.fleet_deleted == False,
+            )
+        )
+    )
+    return list(res.scalars().all())
+
+
+async def schedule_fleet_placement_groups_deletion(
+    session: AsyncSession, fleet_id: UUID, except_placement_group_ids: Iterable[UUID] = ()
+) -> None:
+    await session.execute(
+        update(PlacementGroupModel)
+        .where(
+            and_(
+                PlacementGroupModel.fleet_id == fleet_id,
+                PlacementGroupModel.id.not_in(except_placement_group_ids),
+            )
+        )
+        .values(fleet_deleted=True)  # TODO: rename `fleet_deleted` -> `to_be_deleted`
     )
-    placement_groups = res.scalars().all()
-    return [placement_group_model_to_placement_group(pg) for pg in placement_groups]
 
 
 def placement_group_model_to_placement_group(

dstack/_internal/server/services/resources.py

@@ -0,0 +1,21 @@
+import gpuhunt
+from pydantic import parse_obj_as
+
+from dstack._internal.core.models.resources import CPUSpec, ResourcesSpec
+
+
+def set_resources_defaults(resources: ResourcesSpec) -> None:
+    # TODO: Remove in 0.20. Use resources.cpu directly
+    cpu = parse_obj_as(CPUSpec, resources.cpu)
+    if cpu.arch is None:
+        gpu = resources.gpu
+        if (
+            gpu is not None
+            and gpu.vendor in [None, gpuhunt.AcceleratorVendor.NVIDIA]
+            and gpu.name
+            and any(map(gpuhunt.is_nvidia_superchip, gpu.name))
+        ):
+            cpu.arch = gpuhunt.CPUArchitecture.ARM
+        else:
+            cpu.arch = gpuhunt.CPUArchitecture.X86
+        resources.cpu = cpu

dstack/_internal/server/services/runs.py

@@ -81,6 +81,7 @@ from dstack._internal.server.services.logging import fmt
 from dstack._internal.server.services.offers import get_offers_by_requirements
 from dstack._internal.server.services.plugins import apply_plugin_policies
 from dstack._internal.server.services.projects import list_project_models, list_user_project_models
+from dstack._internal.server.services.resources import set_resources_defaults
 from dstack._internal.server.services.users import get_user_model_by_name
 from dstack._internal.utils.logging import get_logger
 from dstack._internal.utils.random_names import generate_name
@@ -301,12 +302,14 @@ async def get_plan(
             project=project,
             run_name=effective_run_spec.run_name,
         )
-        if (
-            current_resource is not None
-            and not current_resource.status.is_finished()
-            and _can_update_run_spec(current_resource.run_spec, effective_run_spec)
-        ):
-            action = ApplyAction.UPDATE
+        if current_resource is not None:
+            # For backward compatibility (current_resource may has been submitted before
+            # some fields, e.g., CPUSpec.arch, were added)
+            set_resources_defaults(current_resource.run_spec.configuration.resources)
+            if not current_resource.status.is_finished() and _can_update_run_spec(
+                current_resource.run_spec, effective_run_spec
+            ):
+                action = ApplyAction.UPDATE
 
     jobs = await get_jobs_from_run_spec(effective_run_spec, replica_num=0)
 
@@ -406,6 +409,10 @@ async def apply_plan(
             project=project,
             run_spec=run_spec,
         )
+
+    # For backward compatibility (current_resource may has been submitted before
+    # some fields, e.g., CPUSpec.arch, were added)
+    set_resources_defaults(current_resource.run_spec.configuration.resources)
     try:
         _check_can_update_run_spec(current_resource.run_spec, run_spec)
     except ServerClientError:
@@ -414,6 +421,8 @@ async def apply_plan(
             raise ServerClientError("Cannot override active run. Stop the run first.")
         raise
     if not force:
+        if plan.current_resource is not None:
+            set_resources_defaults(plan.current_resource.run_spec.configuration.resources)
         if (
             plan.current_resource is None
             or plan.current_resource.id != current_resource.id
@@ -866,6 +875,7 @@ def _validate_run_spec_and_set_defaults(run_spec: RunSpec):
         raise ServerClientError(
             f"Maximum utilization_policy.time_window is {settings.SERVER_METRICS_TTL_SECONDS}s"
         )
+    set_resources_defaults(run_spec.configuration.resources)
 
 
 _UPDATABLE_SPEC_FIELDS = ["repo_code_hash", "configuration"]

dstack/_internal/server/testing/common.py

@@ -2,7 +2,7 @@ import json
 import uuid
 from contextlib import contextmanager
 from datetime import datetime, timezone
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Literal, Optional, Union
 from uuid import UUID
 
 import gpuhunt
@@ -25,7 +25,12 @@ from dstack._internal.core.models.configurations import (
     DevEnvironmentConfiguration,
 )
 from dstack._internal.core.models.envs import Env
-from dstack._internal.core.models.fleets import FleetConfiguration, FleetSpec, FleetStatus
+from dstack._internal.core.models.fleets import (
+    FleetConfiguration,
+    FleetSpec,
+    FleetStatus,
+    InstanceGroupPlacement,
+)
 from dstack._internal.core.models.gateways import GatewayComputeConfiguration, GatewayStatus
 from dstack._internal.core.models.instances import (
     Disk,
@@ -51,7 +56,7 @@ from dstack._internal.core.models.profiles import (
 )
 from dstack._internal.core.models.repos.base import RepoType
 from dstack._internal.core.models.repos.local import LocalRunRepoData
-from dstack._internal.core.models.resources import Memory, Range, ResourcesSpec
+from dstack._internal.core.models.resources import CPUSpec, Memory, Range, ResourcesSpec
 from dstack._internal.core.models.runs import (
     JobProvisioningData,
     JobRuntimeData,
@@ -497,10 +502,12 @@ def get_fleet_spec(conf: Optional[FleetConfiguration] = None) -> FleetSpec:
 def get_fleet_configuration(
     name: str = "test-fleet",
     nodes: Range[int] = Range(min=1, max=1),
+    placement: Optional[InstanceGroupPlacement] = None,
 ) -> FleetConfiguration:
     return FleetConfiguration(
         name=name,
         nodes=nodes,
+        placement=placement,
     )
 
 
@@ -519,13 +526,13 @@ async def create_instance(
     instance_id: Optional[UUID] = None,
     job: Optional[JobModel] = None,
     instance_num: int = 0,
-    backend: BackendType = BackendType.DATACRUNCH,
+    backend: Optional[BackendType] = BackendType.DATACRUNCH,
     termination_policy: Optional[TerminationPolicy] = None,
     termination_idle_time: int = DEFAULT_FLEET_TERMINATION_IDLE_TIME,
-    region: str = "eu-west",
+    region: Optional[str] = "eu-west",
     remote_connection_info: Optional[RemoteConnectionInfo] = None,
-    offer: Optional[InstanceOfferWithAvailability] = None,
-    job_provisioning_data: Optional[JobProvisioningData] = None,
+    offer: Optional[Union[InstanceOfferWithAvailability, Literal["auto"]]] = "auto",
+    job_provisioning_data: Optional[Union[JobProvisioningData, Literal["auto"]]] = "auto",
     total_blocks: Optional[int] = 1,
     busy_blocks: int = 0,
     name: str = "test_instance",
@@ -534,7 +541,7 @@ async def create_instance(
 ) -> InstanceModel:
     if instance_id is None:
         instance_id = uuid.uuid4()
-    if job_provisioning_data is None:
+    if job_provisioning_data == "auto":
         job_provisioning_data = get_job_provisioning_data(
             dockerized=True,
             backend=backend,
@@ -543,13 +550,13 @@ async def create_instance(
             hostname="running_instance.ip",
             internal_ip=None,
         )
-    if offer is None:
+    if offer == "auto":
         offer = get_instance_offer_with_availability(backend=backend, region=region, spot=spot)
     if profile is None:
         profile = Profile(name="test_name")
 
     if requirements is None:
-        requirements = Requirements(resources=ResourcesSpec(cpu=1))
+        requirements = Requirements(resources=ResourcesSpec(cpu=CPUSpec.parse("1")))
 
     if instance_configuration is None:
         instance_configuration = get_instance_configuration()
@@ -571,8 +578,8 @@ async def create_instance(
         created_at=created_at,
         started_at=created_at,
         finished_at=finished_at,
-        job_provisioning_data=job_provisioning_data.json(),
-        offer=offer.json(),
+        job_provisioning_data=job_provisioning_data.json() if job_provisioning_data else None,
+        offer=offer.json() if offer else None,
         price=price,
         region=region,
         backend=backend,
@@ -659,20 +666,7 @@ def get_remote_connection_info(
     env: Optional[Union[Env, dict]] = None,
 ):
     if ssh_keys is None:
-        ssh_keys = [
-            SSHKey(
-                public="ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIO6mJxVbNtm0zXgMLvByrhXJCmJRveSrJxLB5/OzcyCk",
-                private="""
-                    -----BEGIN OPENSSH PRIVATE KEY-----
-                    b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-                    QyNTUxOQAAACDupicVWzbZtM14DC7wcq4VyQpiUb3kqycSwefzs3MgpAAAAJCiWa5Volmu
-                    VQAAAAtzc2gtZWQyNTUxOQAAACDupicVWzbZtM14DC7wcq4VyQpiUb3kqycSwefzs3MgpA
-                    AAAEAncHi4AhS6XdMp5Gzd+IMse/4ekyQ54UngByf0Sp0uH+6mJxVbNtm0zXgMLvByrhXJ
-                    CmJRveSrJxLB5/OzcyCkAAAACWRlZkBkZWZwYwECAwQ=
-                    -----END OPENSSH PRIVATE KEY-----
-                """,
-            )
-        ]
+        ssh_keys = [get_ssh_key()]
     if env is None:
         env = Env()
     elif isinstance(env, dict):
@@ -686,6 +680,21 @@ def get_remote_connection_info(
     )
 
 
+def get_ssh_key() -> SSHKey:
+    return SSHKey(
+        public="ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIO6mJxVbNtm0zXgMLvByrhXJCmJRveSrJxLB5/OzcyCk",
+        private="""
+                    -----BEGIN OPENSSH PRIVATE KEY-----
+                    b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
+                    QyNTUxOQAAACDupicVWzbZtM14DC7wcq4VyQpiUb3kqycSwefzs3MgpAAAAJCiWa5Volmu
+                    VQAAAAtzc2gtZWQyNTUxOQAAACDupicVWzbZtM14DC7wcq4VyQpiUb3kqycSwefzs3MgpA
+                    AAAEAncHi4AhS6XdMp5Gzd+IMse/4ekyQ54UngByf0Sp0uH+6mJxVbNtm0zXgMLvByrhXJ
+                    CmJRveSrJxLB5/OzcyCkAAAACWRlZkBkZWZwYwECAwQ=
+                    -----END OPENSSH PRIVATE KEY-----
+                """,
+    )
+
+
 async def create_volume(
     session: AsyncSession,
     project: ProjectModel,

dstack/_internal/utils/common.py

@@ -1,4 +1,5 @@
 import asyncio
+import enum
 import itertools
 import re
 import time
@@ -83,6 +84,8 @@ def pretty_date(time: datetime) -> str:
 
 
 def pretty_resources(
+    *,
+    cpu_arch: Optional[Any] = None,
     cpus: Optional[Any] = None,
     memory: Optional[Any] = None,
     gpu_count: Optional[Any] = None,
@@ -110,7 +113,16 @@ def pretty_resources(
     """
     parts = []
     if cpus is not None:
-        parts.append(f"cpu={cpus}")
+        cpu_arch_lower: Optional[str] = None
+        if isinstance(cpu_arch, enum.Enum):
+            cpu_arch_lower = str(cpu_arch.value).lower()
+        elif isinstance(cpu_arch, str):
+            cpu_arch_lower = cpu_arch.lower()
+        if cpu_arch_lower == "arm":
+            cpu_arch_prefix = "arm:"
+        else:
+            cpu_arch_prefix = ""
+        parts.append(f"cpu={cpu_arch_prefix}{cpus}")
     if memory is not None:
         parts.append(f"mem={memory}")
     if disk_size:

dstack/_internal/utils/json_schema.py

@@ -1,6 +1,9 @@
 def add_extra_schema_types(schema_property: dict, extra_types: list[dict]):
     if "allOf" in schema_property:
-        ref = schema_property.pop("allOf")[0]
+        refs = [schema_property.pop("allOf")[0]]
+    elif "anyOf" in schema_property:
+        refs = schema_property.pop("anyOf")
     else:
-        ref = {"type": schema_property.pop("type")}
-    schema_property["anyOf"] = [ref, *extra_types]
+        refs = [{"type": schema_property.pop("type")}]
+    refs.extend(extra_types)
+    schema_property["anyOf"] = refs

dstack/api/__init__.py

@@ -14,6 +14,7 @@ from dstack._internal.core.models.repos.local import LocalRepo
 from dstack._internal.core.models.repos.remote import RemoteRepo
 from dstack._internal.core.models.repos.virtual import VirtualRepo
 from dstack._internal.core.models.resources import ComputeCapability, Memory, Range
+from dstack._internal.core.models.resources import CPUSpec as CPU
 from dstack._internal.core.models.resources import DiskSpec as Disk
 from dstack._internal.core.models.resources import GPUSpec as GPU
 from dstack._internal.core.models.resources import ResourcesSpec as Resources

dstack/api/server/_fleets.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import parse_obj_as
 
 from dstack._internal.core.models.fleets import ApplyFleetPlanInput, Fleet, FleetPlan, FleetSpec
+from dstack._internal.core.models.instances import Instance
 from dstack._internal.server.schemas.fleets import (
     ApplyFleetPlanRequest,
     CreateFleetRequest,
@@ -83,9 +84,24 @@ def _get_apply_plan_excludes(plan_input: ApplyFleetPlanInput) -> Dict:
     spec_excludes = _get_fleet_spec_excludes(plan_input.spec)
     if spec_excludes:
         apply_plan_excludes["spec"] = apply_plan_excludes
+    current_resource = plan_input.current_resource
+    if current_resource is not None:
+        current_resource_excludes = {}
+        apply_plan_excludes["current_resource"] = current_resource_excludes
+        if all(map(_should_exclude_instance_cpu_arch, current_resource.instances)):
+            current_resource_excludes["instances"] = {
+                "__all__": {"instance_type": {"resources": {"cpu_arch"}}}
+            }
     return {"plan": apply_plan_excludes}
 
 
+def _should_exclude_instance_cpu_arch(instance: Instance) -> bool:
+    try:
+        return instance.instance_type.resources.cpu_arch is None
+    except AttributeError:
+        return True
+
+
 def _get_create_fleet_excludes(fleet_spec: FleetSpec) -> Dict:
     create_fleet_excludes = {}
     spec_excludes = _get_fleet_spec_excludes(fleet_spec)

dstack/api/server/_runs.py

@@ -7,6 +7,7 @@ from pydantic import parse_obj_as
 from dstack._internal.core.models.configurations import ServiceConfiguration
 from dstack._internal.core.models.runs import (
     ApplyRunPlanInput,
+    JobSubmission,
     Run,
     RunPlan,
     RunSpec,
@@ -96,13 +97,53 @@ def _get_apply_plan_excludes(plan: ApplyRunPlanInput) -> Optional[Dict]:
     run_spec_excludes = _get_run_spec_excludes(plan.run_spec)
     if run_spec_excludes is not None:
         apply_plan_excludes["run_spec"] = run_spec_excludes
-    if plan.current_resource is not None:
-        apply_plan_excludes["current_resource"] = {
-            "run_spec": _get_run_spec_excludes(plan.current_resource.run_spec)
+    current_resource = plan.current_resource
+    if current_resource is not None:
+        current_resource_excludes = {}
+        apply_plan_excludes["current_resource"] = current_resource_excludes
+        current_resource_excludes["run_spec"] = _get_run_spec_excludes(current_resource.run_spec)
+        job_submissions_excludes = {}
+        current_resource_excludes["jobs"] = {
+            "__all__": {"job_submissions": {"__all__": job_submissions_excludes}}
         }
+        job_submissions = [js for j in current_resource.jobs for js in j.job_submissions]
+        if all(map(_should_exclude_job_submission_jpd_cpu_arch, job_submissions)):
+            job_submissions_excludes["job_provisioning_data"] = {
+                "instance_type": {"resources": {"cpu_arch"}}
+            }
+        if all(map(_should_exclude_job_submission_jrd_cpu_arch, job_submissions)):
+            job_submissions_excludes["job_runtime_data"] = {
+                "offer": {"instance": {"resources": {"cpu_arch"}}}
+            }
+        latest_job_submission = current_resource.latest_job_submission
+        if latest_job_submission is not None:
+            latest_job_submission_excludes = {}
+            current_resource_excludes["latest_job_submission"] = latest_job_submission_excludes
+            if _should_exclude_job_submission_jpd_cpu_arch(latest_job_submission):
+                latest_job_submission_excludes["job_provisioning_data"] = {
+                    "instance_type": {"resources": {"cpu_arch"}}
+                }
+            if _should_exclude_job_submission_jrd_cpu_arch(latest_job_submission):
+                latest_job_submission_excludes["job_runtime_data"] = {
+                    "offer": {"instance": {"resources": {"cpu_arch"}}}
+                }
     return {"plan": apply_plan_excludes}
 
 
+def _should_exclude_job_submission_jpd_cpu_arch(job_submission: JobSubmission) -> bool:
+    try:
+        return job_submission.job_provisioning_data.instance_type.resources.cpu_arch is None
+    except AttributeError:
+        return True
+
+
+def _should_exclude_job_submission_jrd_cpu_arch(job_submission: JobSubmission) -> bool:
+    try:
+        return job_submission.job_runtime_data.offer.instance.resources.cpu_arch is None
+    except AttributeError:
+        return True
+
+
 def _get_get_plan_excludes(request: GetRunPlanRequest) -> Optional[Dict]:
     """
     Excludes new fields when they are not set to keep

dstack/version.py

@@ -1,3 +1,3 @@
-__version__ = "0.19.7"
+__version__ = "0.19.8"
 __is_release__ = True
 base_image = "0.7"

{dstack-0.19.7.dist-info → dstack-0.19.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dstack
-Version: 0.19.7
+Version: 0.19.8
 Summary: dstack is an open-source orchestration engine for running AI workloads on any cloud or on-premises.
 Project-URL: Homepage, https://dstack.ai
 Project-URL: Source, https://github.com/dstackai/dstack
@@ -49,6 +49,7 @@ Requires-Dist: asyncpg; extra == 'all'
 Requires-Dist: azure-identity>=1.12.0; extra == 'all'
 Requires-Dist: azure-mgmt-authorization>=3.0.0; extra == 'all'
 Requires-Dist: azure-mgmt-compute>=29.1.0; extra == 'all'
+Requires-Dist: azure-mgmt-msi>=7.0.0; extra == 'all'
 Requires-Dist: azure-mgmt-network<28.0.0,>=23.0.0; extra == 'all'
 Requires-Dist: azure-mgmt-resource>=22.0.0; extra == 'all'
 Requires-Dist: azure-mgmt-subscription>=3.1.1; extra == 'all'
@@ -116,6 +117,7 @@ Requires-Dist: asyncpg; extra == 'azure'
 Requires-Dist: azure-identity>=1.12.0; extra == 'azure'
 Requires-Dist: azure-mgmt-authorization>=3.0.0; extra == 'azure'
 Requires-Dist: azure-mgmt-compute>=29.1.0; extra == 'azure'
+Requires-Dist: azure-mgmt-msi>=7.0.0; extra == 'azure'
 Requires-Dist: azure-mgmt-network<28.0.0,>=23.0.0; extra == 'azure'
 Requires-Dist: azure-mgmt-resource>=22.0.0; extra == 'azure'
 Requires-Dist: azure-mgmt-subscription>=3.1.1; extra == 'azure'