lightning-sdk 2025.8.6rc2__py3-none-any.whl → 2025.11.5__py3-none-any.whl

lightning_sdk/__init__.py

@@ -1,27 +1,31 @@
+from lightning_sdk.__version__ import __version__
 from lightning_sdk.agents import Agent
 from lightning_sdk.ai_hub import AIHub
 from lightning_sdk.constants import __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__  # noqa: F401
 from lightning_sdk.deployment import Deployment
-from lightning_sdk.helpers import _check_version_and_prompt_upgrade, _set_tqdm_envvars_noninteractive
+from lightning_sdk.helpers import VersionChecker, set_tqdm_envvars_noninteractive
 from lightning_sdk.job import Job
 from lightning_sdk.machine import CloudProvider, Machine
 from lightning_sdk.mmt import MMT
 from lightning_sdk.organization import Organization
 from lightning_sdk.plugin import JobsPlugin, MultiMachineTrainingPlugin, Plugin, SlurmJobsPlugin
 from lightning_sdk.status import Status
-from lightning_sdk.studio import Studio
-from lightning_sdk.teamspace import Teamspace
+from lightning_sdk.studio import VM, Studio
+from lightning_sdk.teamspace import ConnectionType, FolderLocation, Teamspace
 from lightning_sdk.user import User
 
 __all__ = [
+    "MMT",
+    "VM",
     "AIHub",
     "Agent",
     "CloudProvider",
+    "ConnectionType",
     "Deployment",
+    "FolderLocation",
     "Job",
     "JobsPlugin",
     "Machine",
-    "MMT",
     "MultiMachineTrainingPlugin",
     "Organization",
     "Plugin",
@@ -30,8 +34,10 @@ __all__ = [
     "Studio",
     "Teamspace",
     "User",
+    "__version__",
 ]
 
-__version__ = "2025.08.06rc2"
-_check_version_and_prompt_upgrade(__version__)
-_set_tqdm_envvars_noninteractive()
+_version_checker = VersionChecker()
+_version_checker.check_and_prompt_upgrade(__version__)
+
+set_tqdm_envvars_noninteractive()

lightning_sdk/__version__.py

@@ -0,0 +1,3 @@
+"""Version information for lightning_sdk."""
+
+__version__ = "2025.11.05"

lightning_sdk/agents.py

@@ -1,9 +1,10 @@
 from typing import List, Optional
 
 from lightning_sdk.api.agents_api import AgentApi
+from lightning_sdk.utils.logging import TrackCallsMeta
 
 
-class Agent:
+class Agent(metaclass=TrackCallsMeta):
     def __init__(self, agent_id: str) -> None:
         self.id = agent_id
         self._agent_api = AgentApi()

lightning_sdk/ai_hub.py

@@ -5,6 +5,7 @@ from lightning_sdk.api import AIHubApi
 from lightning_sdk.api.utils import _get_cloud_url
 from lightning_sdk.lightning_cloud.openapi.models import V1Deployment
 from lightning_sdk.user import User
+from lightning_sdk.utils.logging import TrackCallsMeta
 from lightning_sdk.utils.resolve import _resolve_teamspace
 
 if TYPE_CHECKING:
@@ -12,7 +13,7 @@ if TYPE_CHECKING:
     from lightning_sdk.machine import Machine
 
 
-class AIHub:
+class AIHub(metaclass=TrackCallsMeta):
     """An interface to interact with the AI Hub.
 
     Example:

lightning_sdk/api/__init__.py

@@ -1,5 +1,6 @@
 from lightning_sdk.api.agents_api import AgentApi
 from lightning_sdk.api.ai_hub_api import AIHubApi
+from lightning_sdk.api.cloud_account_api import CloudAccountApi
 from lightning_sdk.api.org_api import OrgApi
 from lightning_sdk.api.studio_api import StudioApi
 from lightning_sdk.api.teamspace_api import TeamspaceApi
@@ -12,4 +13,5 @@ __all__ = [
     "UserApi",
     "AgentApi",
     "AIHubApi",
+    "CloudAccountApi",
 ]

lightning_sdk/api/base_studio_api.py

@@ -15,24 +15,28 @@ class BaseStudioApi:
     def __init__(self) -> None:
         self._client = LightningClient(retry=False, max_tries=0)
 
-    def get_base_studio(self, base_studio_id: str, org_id: str) -> V1CloudSpaceEnvironmentTemplate:
+    def get_base_studio(self, base_studio_id: str, org_id: Optional[str] = None) -> V1CloudSpaceEnvironmentTemplate:
         """Retrieve the base studio by its ID."""
         try:
             return self._client.cloud_space_environment_template_service_get_cloud_space_environment_template(
-                base_studio_id, org_id=org_id
+                base_studio_id, org_id=org_id or ""
             )
         except ValueError as e:
             raise ValueError(f"Base studio {base_studio_id} does not exist") from e
 
-    def get_all_base_studios(self, org_id: str, managed: bool = True) -> V1ListCloudSpaceEnvironmentTemplatesResponse:
+    def get_all_base_studios(self, org_id: Optional[str]) -> V1ListCloudSpaceEnvironmentTemplatesResponse:
         """Retrieve all base studios for a given organization."""
-        if managed:
-            return self._client.cloud_space_environment_template_service_list_managed_cloud_space_environment_templates(
-                org_id=org_id
-            )
-        return self._client.cloud_space_environment_template_service_list_cloud_space_environment_templates(
-            org_id=org_id
+        result = self._client.cloud_space_environment_template_service_list_managed_cloud_space_environment_templates(
+            org_id=org_id or ""
         )
+        if org_id is not None:
+            org_templates = (
+                self._client.cloud_space_environment_template_service_list_cloud_space_environment_templates(
+                    org_id=org_id
+                )
+            )
+            result.templates = result.templates + org_templates.templates
+        return result
 
     def update_base_studio(
         self,

lightning_sdk/api/cloud_account_api.py

@@ -13,6 +13,7 @@ from lightning_sdk.lightning_cloud.rest_client import LightningClient
 
 if TYPE_CHECKING:
     from lightning_sdk.machine import CloudProvider
+    from lightning_sdk.teamspace import ConnectionType
 
 
 class CloudAccountApi:
@@ -131,13 +132,20 @@ class CloudAccountApi:
         )
         return list(filtered_cloud_accounts)
 
-    def get_cloud_account_provider_mapping(self, teamspace_id: str) -> Dict["CloudProvider", str]:
+    def get_cloud_account_provider_mapping(self, teamspace_id: str) -> Dict["CloudProvider", V1ExternalCluster]:
         """Gets the cloud account <-> provider mapping."""
-        res = self.list_global_cloud_accounts(teamspace_id=teamspace_id)
-        return {self._get_cloud_account_provider(cloud_account): cloud_account.id for cloud_account in res}
+        res = self.list_cloud_accounts(teamspace_id=teamspace_id)
+        cloud_accounts = {cloud_account.id: cloud_account for cloud_account in res}
+        providers = {cloud_account.id: self._get_cloud_account_provider(cloud_account) for cloud_account in res}
+
+        mapping = {}
+        for cloud_account_id, provider in providers.items():
+            if provider is not None:
+                mapping[provider] = cloud_accounts[cloud_account_id]
+        return mapping
 
     @staticmethod
-    def _get_cloud_account_provider(cloud_account: Optional[V1ExternalCluster]) -> "CloudProvider":
+    def _get_cloud_account_provider(cloud_account: Optional[V1ExternalCluster]) -> Optional["CloudProvider"]:
         """Determines the cloud provider based on the cloud_account configuration.
 
         Args:
@@ -165,14 +173,12 @@ class CloudAccountApi:
                 return CloudProvider.GCP
             if cloud_account.spec.lambda_labs_v1:
                 return CloudProvider.LAMBDA_LABS
-            if cloud_account.spec.vultr_v1:
-                return CloudProvider.VULTR
             if cloud_account.spec.voltage_park_v1:
                 return CloudProvider.VOLTAGE_PARK
             if cloud_account.spec.nebius_v1:
                 return CloudProvider.NEBIUS
 
-        return CloudProvider.AWS
+        return None
 
     def resolve_cloud_account(
         self,
@@ -181,14 +187,19 @@ class CloudAccountApi:
         cloud_provider: Optional[Union["CloudProvider", str]],
         default_cloud_account: Optional[str],
     ) -> Optional[str]:
+        from lightning_sdk.machine import CloudProvider
+
+        if cloud_provider and not isinstance(cloud_provider, CloudProvider):
+            cloud_provider = CloudProvider(cloud_provider)
+
         if cloud_account:
             if cloud_provider:
                 cloud_account_resp = self.get_cloud_account_non_org(teamspace_id, cloud_account)
                 cloud_provider_resp = self._get_cloud_account_provider(cloud_account_resp)
                 if cloud_provider_resp != cloud_provider:
                     raise RuntimeError(
-                        f"Specified both cloud_provider ({cloud_provider}) and "
-                        "cloud_account ({cloud_account} has cloud provider {cloud_provider_resp}) which don't match!"
+                        f"Specified both cloud_provider ({cloud_provider}) and cloud_account ({cloud_account} "
+                        f"has cloud provider {cloud_provider_resp}) which don't match!"
                     )
 
             return cloud_account
@@ -196,9 +207,19 @@ class CloudAccountApi:
         if cloud_provider:
             cloud_account_mapping = self.get_cloud_account_provider_mapping(teamspace_id=teamspace_id)
             if cloud_provider and cloud_provider in cloud_account_mapping:
-                return cloud_account_mapping[cloud_provider]
+                return cloud_account_mapping[cloud_provider].id
 
         if default_cloud_account:
             return default_cloud_account
 
         return None
+
+    @staticmethod
+    def get_cloud_provider_for_connection_type(connection_type: "ConnectionType") -> "CloudProvider":
+        from lightning_sdk.machine import CloudProvider
+        from lightning_sdk.teamspace import ConnectionType
+
+        if connection_type == ConnectionType.EFS:
+            return CloudProvider.AWS
+
+        raise ValueError(f"ConnectionType {ConnectionType} currently not supported!")

lightning_sdk/api/deployment_api.py

@@ -1,7 +1,7 @@
 from time import sleep
 from typing import Any, Dict, List, Literal, Optional, Union
 
-from lightning_sdk.api.utils import _machine_to_compute_name
+from lightning_sdk.api.utils import _machine_to_compute_name, resolve_path_mappings
 from lightning_sdk.lightning_cloud.openapi import (
     CreateDeploymentRequestDefinesASpecForTheJobThatAllowsForAutoscalingJobs,
     V1AutoscalingSpec,
@@ -58,6 +58,10 @@ class TokenAuth(Auth):
         self.token = token
 
 
+class ApiKeyAuth(Auth):
+    """The ApiKeyAuth describes that the user requires a Lightning API Key to authenticate."""
+
+
 class ReleaseStrategy:
     """The base class for release strategy."""
 
@@ -265,6 +269,7 @@ class DeploymentApi:
         quantity: Optional[int] = None,
         include_credentials: Optional[bool] = None,
         max_runtime: Optional[int] = None,
+        path_mappings: Optional[Dict[str, str]] = None,
     ) -> V1Deployment:
         # Update the deployment in place
 
@@ -284,6 +289,11 @@ class DeploymentApi:
         requires_release = False
         requires_release |= apply_change(deployment.spec, "image", image)
 
+        if path_mappings:
+            requires_release |= apply_change(
+                deployment.spec, "path_mappings", resolve_path_mappings(path_mappings, None, None)
+            )
+
         requires_release |= apply_change(deployment.spec, "entrypoint", entrypoint)
         requires_release |= apply_change(deployment.spec, "command", command)
         requires_release |= apply_change(deployment.spec, "env", to_env(env))
@@ -300,6 +310,10 @@ class DeploymentApi:
             if deployment.strategy is None:
                 raise RuntimeError("When doing a new release, a release strategy needs to be defined.")
 
+            # Force the deployment to make a new snapshot
+            if deployment.spec.cloudspace_id != "" and deployment.spec.run_id != "":
+                deployment.spec.run_id = ""
+
             print("Some core arguments have changed. We are making a new release.")
 
         apply_change(deployment.endpoint, "custom_domain", custom_domain)
@@ -371,11 +385,15 @@ def restore_auth(auth: Optional[V1EndpointAuth] = None) -> Optional[Auth]:
     if not auth:
         return None
 
+    if auth.user_api_key:
+        return ApiKeyAuth()
+
     if auth.username and auth.password:
         return BasicAuth(username=auth.username, password=auth.password)
 
     if auth.token:
         return TokenAuth(token=auth.token)
+
     return None
 
 
@@ -512,6 +530,10 @@ def to_endpoint_auth(auth: Optional[Auth] = None) -> Optional[V1EndpointAuth]:
             raise ValueError("The token should be defined.")
 
         return V1EndpointAuth(enabled=True, token=auth.token)
+
+    if isinstance(auth, ApiKeyAuth):
+        return V1EndpointAuth(enabled=True, user_api_key=True)
+
     return None
 
 
@@ -575,6 +597,7 @@ def to_spec(
     cloudspace_id: Optional[None] = None,
     max_runtime: Optional[int] = None,
     machine_image_version: Optional[str] = None,
+    path_mappings: Optional[Dict[str, str]] = None,
 ) -> V1JobSpec:
     if cloud_account is None:
         raise ValueError("The cloud account should be defined.")
@@ -596,6 +619,8 @@ def to_spec(
     if max_runtime:
         optional_spec_kwargs["requested_run_duration_seconds"] = str(max_runtime)
 
+    path_mapping_list = resolve_path_mappings(path_mappings or {}, None, None)
+
     return V1JobSpec(
         cluster_id=cloud_account,
         command=command,
@@ -609,6 +634,7 @@ def to_spec(
         include_credentials=include_credentials,
         cloudspace_id=cloudspace_id,
         machine_image_version=machine_image_version,
+        path_mappings=path_mapping_list,
         **optional_spec_kwargs,
     )
 

lightning_sdk/api/job_api.py

@@ -104,22 +104,23 @@ class JobApiV1:
             org_id=org_id,
         )
 
-        identifier = None
+        identifiers = []
 
         if user_requested_compute_config and user_requested_compute_config.name:
-            identifier = user_requested_compute_config.name
+            identifiers.append(user_requested_compute_config.name)
         else:
-            identifier = spec.compute_config.instance_type
+            identifiers.append(spec.compute_config.instance_type)
 
         for accelerator in accelerators:
-            if identifier in (
-                accelerator.slug,
-                accelerator.slug_multi_cloud,
-                accelerator.instance_id,
-            ):
-                return Machine.from_str(accelerator.slug_multi_cloud)
+            for ident in identifiers:
+                if ident in (
+                    accelerator.slug,
+                    accelerator.slug_multi_cloud,
+                    accelerator.instance_id,
+                ):
+                    return Machine._from_accelerator(accelerator)
 
-        return Machine.from_str(identifier)
+        return Machine.from_str(identifiers[0])
 
     def _get_machines_for_cloud_account(
         self, teamspace_id: str, cloud_account_id: str, org_id: str
@@ -249,6 +250,7 @@ class JobApiV2:
         artifacts_local: Optional[str],  # deprecated in favor of path_mappings
         artifacts_remote: Optional[str],  # deprecated in favor of path_mappings
         max_runtime: Optional[int] = None,
+        reuse_snapshot: bool = True,
     ) -> V1Job:
         body = self._create_job_body(
             name=name,
@@ -266,6 +268,7 @@ class JobApiV2:
             artifacts_local=artifacts_local,
             artifacts_remote=artifacts_remote,
             max_runtime=max_runtime,
+            reuse_snapshot=reuse_snapshot,
         )
 
         job: V1Job = self._client.jobs_service_create_job(project_id=teamspace_id, body=body)
@@ -287,6 +290,7 @@ class JobApiV2:
         path_mappings: Optional[Dict[str, str]],
         artifacts_local: Optional[str],  # deprecated in favor of path_mappings
         artifacts_remote: Optional[str],  # deprecated in favor of path_mappings)
+        reuse_snapshot: bool,
         max_runtime: Optional[int] = None,
         machine_image_version: Optional[str] = None,
     ) -> ProjectIdJobsBody:
@@ -297,7 +301,7 @@ class JobApiV2:
 
         instance_name = _machine_to_compute_name(machine)
 
-        run_id = __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__[studio_id] if studio_id is not None else ""
+        run_id = __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__[studio_id] if (studio_id is not None and reuse_snapshot) else ""
 
         path_mappings_list = resolve_path_mappings(
             mappings=path_mappings or {},
@@ -431,7 +435,7 @@ class JobApiV2:
             if (spec.instance_name and spec.instance_name in possible_identifiers) or (
                 spec.instance_type and spec.instance_type in possible_identifiers
             ):
-                return Machine.from_str(accelerator.slug_multi_cloud)
+                return Machine._from_accelerator(accelerator)
 
         return Machine.from_str(spec.instance_name or spec.instance_type)
 

lightning_sdk/api/license_api.py

@@ -1,70 +1,37 @@
-import os
-from typing import Optional
-from urllib.parse import urlencode
-
-from lightning_sdk.lightning_cloud import env
-from lightning_sdk.lightning_cloud.rest_client import LightningClient
-
-LICENSE_CODE = os.environ.get("LICENSE_CODE", "d9s79g79ss")
-# https://lightning.ai/home?settings=licenses
-LICENSE_SIGNING_URL = f"{env.LIGHTNING_CLOUD_URL}?settings=licenses"
-
-
-def generate_url_user_settings(name: str, redirect_to: str = LICENSE_SIGNING_URL) -> str:
-    params = urlencode({"redirectTo": redirect_to, "okbhrt": LICENSE_CODE, "licenseName": name})
-    return f"{env.LIGHTNING_CLOUD_URL}/sign-in?{params}"
+from lightning_sdk.api.utils import _get_cloud_url as _cloud_url
+from lightning_sdk.lightning_cloud.login import Auth
+from lightning_sdk.lightning_cloud.openapi import LicenseKeyValidateBody, ProductLicenseServiceApi
 
 
 class LicenseApi:
-    _client_authenticated: LightningClient = None
-    _client_public: LightningClient = None
-
-    @property
-    def client_public(self) -> LightningClient:
-        if not self._client_public:
-            self._client_public = LightningClient(retry=False, max_tries=0, with_auth=False)
-        return self._client_public
-
-    @property
-    def client_authenticated(self) -> LightningClient:
-        if not self._client_authenticated:
-            self._client_authenticated = LightningClient(retry=True, max_tries=3, with_auth=True)
-        return self._client_authenticated
+    def __init__(self, login_token: str) -> None:
+        self._cloud_url = _cloud_url()
+        self._auth = Auth()
+        self._auth.token_login(login_token, save_token=True)
+        self._client = self._auth.create_api_client()
+        self._api = ProductLicenseServiceApi(self._client)
 
-    def valid_license(
-        self,
-        license_key: str,
-        product_name: str,
-        product_version: Optional[str] = None,
-        product_type: str = "package",
-    ) -> bool:
-        """Check if the license key is valid.
+    def validate_license(self, license_key: str, product_id: str) -> bool:
+        """Validate a license key for a specific product.
 
         Args:
-            license_key: The license key to check.
-            product_name: The name of the product.
-            product_version: The version of the product.
-            product_type: The type of the product. Default is "package".
+            license_key: The license key to validate
+            product_id: The product ID
 
         Returns:
-            True if the license key is valid, False otherwise.
-        """
-        response = self.client_public.product_license_service_validate_product_license(
-            license_key=license_key,
-            product_name=product_name,
-            product_version=product_version,
-            product_type=product_type,
-        )
-        return response.valid
+            bool: True if license is valid, False otherwise
 
-    def list_user_licenses(self, user_id: str) -> list:
-        """List all licenses for a user.
+        Raises:
+            Exception: If license validation fails
+        """
+        try:
+            response = self._api.product_license_service_validate_license(
+                body=LicenseKeyValidateBody(product_id=product_id), license_key=license_key
+            )
+            return response.is_valid
+        except Exception:
+            raise InvalidLicenseError(f"Invalid license key {license_key} for product {product_id}") from None
 
-        Args:
-            user_id: The ID of the user.
 
-        Returns:
-            A list of licenses for the user.
-        """
-        response = self.client_authenticated.product_license_service_list_user_licenses(user_id=user_id)
-        return response.licenses
+class InvalidLicenseError(Exception):
+    pass

lightning_sdk/api/llm_api.py

@@ -16,6 +16,7 @@ from lightning_sdk.lightning_cloud.login import Auth, AuthServer
 from lightning_sdk.lightning_cloud.openapi.models import (
     StreamResultOfV1ConversationResponseChunk,
     V1ConversationResponseChunk,
+    V1ManagedModel,
     V1ResponseChoice,
     V1ResponseChoiceDelta,
 )
@@ -67,13 +68,23 @@ def authenticate(model: str, shall_confirm: bool = True) -> None:
 class LLMApi:
     def __init__(self) -> None:
         self._client = LightningClient(retry=False, max_tries=0)
+        self._assistant = None
+        self._model = None
 
     def get_assistant(self, model_provider: str, model_name: str, user_name: str, org_name: str) -> str:
         result = self._client.assistants_service_get_managed_model_assistant(
             model_provider=model_provider, model_name=model_name, user_name=user_name, org_name=org_name
         )
+        self._assistant = result
         return result.id
 
+    def get_model_metadata(self, teamspace_id: str, model_name: str) -> V1ManagedModel:
+        if self._assistant and not self._model:
+            self._model = self._client.assistants_service_get_managed_model_by_name(
+                teamspace_id, self._assistant.managed_endpoint_id, model_name
+            )
+        return self._model
+
     def _parse_stream_line(self, decoded_line: str) -> Optional[V1ConversationResponseChunk]:
         try:
             payload = json.loads(decoded_line)
@@ -132,6 +143,7 @@ class LLMApi:
         metadata: Optional[Dict[str, str]] = None,
         stream: bool = False,
         tools: Optional[List[Dict[str, Any]]] = None,
+        reasoning_effort: Optional[str] = None,
         **kwargs: Any,
     ) -> Union[V1ConversationResponseChunk, Generator[V1ConversationResponseChunk, None, None]]:
         is_internal_conversation = os.getenv("LIGHTNING_INTERNAL_CONVERSATION", "false").lower() == "true"
@@ -146,7 +158,6 @@ class LLMApi:
                     {"contentType": "text", "parts": [prompt]},
                 ],
             },
-            "max_tokens": max_completion_tokens,
             "conversation_id": conversation_id,
             "billing_project_id": billing_project_id,
             "name": name,
@@ -159,6 +170,12 @@ class LLMApi:
             "parent_message_id": kwargs.get("parent_message_id", ""),
             "tools": tools,
         }
+        if max_completion_tokens is not None:
+            body["max_completion_tokens"] = max_completion_tokens
+
+        if reasoning_effort:
+            body["reasoning_effort"] = reasoning_effort
+
         if images:
             for image in images:
                 url = image
@@ -189,6 +206,7 @@ class LLMApi:
         name: Optional[str] = None,
         metadata: Optional[Dict[str, str]] = None,
         stream: bool = False,
+        reasoning_effort: Optional[str] = None,
         **kwargs: Any,
     ) -> Union[V1ConversationResponseChunk, AsyncGenerator[V1ConversationResponseChunk, None]]:
         is_internal_conversation = os.getenv("LIGHTNING_INTERNAL_CONVERSATION", "false").lower() == "true"
@@ -203,7 +221,6 @@ class LLMApi:
                     {"contentType": "text", "parts": [prompt]},
                 ],
             },
-            "max_completion_tokens": max_completion_tokens,
             "conversation_id": conversation_id,
             "billing_project_id": billing_project_id,
             "name": name,
@@ -216,6 +233,12 @@ class LLMApi:
             "parent_message_id": kwargs.get("parent_message_id", ""),
             "sent_at": datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="microseconds"),
         }
+        if max_completion_tokens is not None:
+            body["max_completion_tokens"] = max_completion_tokens
+
+        if reasoning_effort:
+            body["reasoning_effort"] = reasoning_effort
+
         if images:
             for image in images:
                 url = image

lightning_sdk/api/mmt_api.py

@@ -88,6 +88,7 @@ class MMTApiV2:
         artifacts_local: Optional[str],  # deprecated in favor of path_mappings
         artifacts_remote: Optional[str],  # deprecated in favor of path_mappings
         max_runtime: Optional[int],
+        reuse_snapshot: bool,
     ) -> V1MultiMachineJob:
         body = self._create_mmt_body(
             name=name,
@@ -106,6 +107,7 @@ class MMTApiV2:
             artifacts_local=artifacts_local,  # deprecated in favor of path_mappings
             artifacts_remote=artifacts_remote,  # deprecated in favor of path_mappings
             max_runtime=max_runtime,
+            reuse_snapshot=reuse_snapshot,
         )
 
         job: V1MultiMachineJob = self._client.jobs_service_create_multi_machine_job(project_id=teamspace_id, body=body)
@@ -128,6 +130,7 @@ class MMTApiV2:
         path_mappings: Optional[Dict[str, str]],
         artifacts_local: Optional[str],  # deprecated in favor of path_mappings
         artifacts_remote: Optional[str],  # deprecated in favor of path_mappings
+        reuse_snapshot: bool,
         max_runtime: Optional[int] = None,
         machine_image_version: Optional[str] = None,
     ) -> ProjectIdMultimachinejobsBody:
@@ -138,7 +141,7 @@ class MMTApiV2:
 
         instance_name = _machine_to_compute_name(machine)
 
-        run_id = __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__[studio_id] if studio_id is not None else ""
+        run_id = __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__[studio_id] if (studio_id is not None and reuse_snapshot) else ""
 
         path_mappings_list = resolve_path_mappings(
             mappings=path_mappings or {},
@@ -265,7 +268,7 @@ class MMTApiV2:
             if (spec.instance_name and spec.instance_name in possible_identifiers) or (
                 spec.instance_type and spec.instance_type in possible_identifiers
             ):
-                return Machine.from_str(accelerator.slug_multi_cloud)
+                return Machine._from_accelerator(accelerator)
 
         return Machine.from_str(spec.instance_name or spec.instance_type)