lightning-sdk 0.1.49__py3-none-any.whl → 2025.11.5__py3-none-any.whl

lightning_sdk/__init__.py

@@ -1,22 +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.helpers import _check_version_and_prompt_upgrade
+from lightning_sdk.deployment import Deployment
+from lightning_sdk.helpers import VersionChecker, set_tqdm_envvars_noninteractive
 from lightning_sdk.job import Job
-from lightning_sdk.machine import Machine
+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",
@@ -25,9 +34,10 @@ __all__ = [
     "Studio",
     "Teamspace",
     "User",
-    "Agent",
-    "AIHub",
+    "__version__",
 ]
 
-__version__ = "0.1.49"
-_check_version_and_prompt_upgrade(__version__)
+_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

@@ -1,17 +1,19 @@
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 from urllib.parse import quote
 
-from lightning_sdk.api import AIHubApi, UserApi
-from lightning_sdk.lightning_cloud import login
-from lightning_sdk.lightning_cloud.env import LIGHTNING_CLOUD_URL
+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.resolve import _resolve_org, _resolve_teamspace
+from lightning_sdk.utils.logging import TrackCallsMeta
+from lightning_sdk.utils.resolve import _resolve_teamspace
 
 if TYPE_CHECKING:
     from lightning_sdk import Organization, Teamspace
+    from lightning_sdk.machine import Machine
 
 
-class AIHub:
+class AIHub(metaclass=TrackCallsMeta):
     """An interface to interact with the AI Hub.
 
     Example:
@@ -99,26 +101,6 @@ class AIHub:
             results.append(result)
         return results
 
-    def _authenticate(
-        self,
-        teamspace: Optional[Union[str, "Teamspace"]] = None,
-        org: Optional[Union[str, "Organization"]] = None,
-        user: Optional[Union[str, "User"]] = None,
-    ) -> "Teamspace":
-        if self._auth is None:
-            self._auth = login.Auth()
-        try:
-            self._auth.authenticate()
-            user = User(name=UserApi()._get_user_by_id(self._auth.user_id).username)
-        except ConnectionError as e:
-            raise e
-
-        org = _resolve_org(org)
-        teamspace = _resolve_teamspace(teamspace=teamspace, org=org, user=user if org is None else None)
-        if teamspace is None:
-            raise ValueError("You need to pass a teamspace or an org for your deployment.")
-        return teamspace
-
     def run(
         self,
         api_id: str,
@@ -127,7 +109,10 @@ class AIHub:
         cloud_account: Optional[str] = None,
         teamspace: Optional[Union[str, "Teamspace"]] = None,
         org: Optional[Union[str, "Organization"]] = None,
-    ) -> Dict[str, Union[str, bool]]:
+        user: Optional[Union[str, "User"]] = None,
+        machine: Optional[Union[str, "Machine"]] = None,
+        quantity: Optional[int] = None,
+    ) -> V1Deployment:
         """Deploy an API from the AI Hub.
 
         Example:
@@ -144,19 +129,27 @@ class AIHub:
             api_arguments: Additional API argument, such as model name, or batch size.
             name: Name for the deployed API. Defaults to None.
             cloud_account: The cloud account where you want to run the template, such as "lightning-public-prod".
-                Defaults to None.
+                Defaults to None, which will use the cloud account of the teamspace.
             teamspace: The team or group for deployment. Defaults to None.
-            org: The organization for deployment. Defaults to None.
+            org: The organization for deployment. Don't pass user with this. Defaults to None.
+            user: The user for deployment. Don't pass org with this. Defaults to None.
+            machine: The machine to run the deployment on. Defaults to the first option set in the AI Hub template.
 
         Returns:
-            A dictionary containing the name of the deployed API,
+            A V1Deployment object containing the name of the deployed API,
             the URL to access it, and whether it is interruptible.
 
         Raises:
             ValueError: If a teamspace or organization is not provided.
             ConnectionError: If there is an issue with logging in.
         """
-        teamspace = self._authenticate(teamspace, org)
+        if user is not None and org is not None:
+            raise ValueError("User and org are mutually exclusive. Please only specify the one owns the teamspace.")
+
+        teamspace = _resolve_teamspace(teamspace=teamspace, org=org, user=user)
+        if teamspace is None:
+            raise ValueError("You need to pass a teamspace or an org for your deployment.")
+
         teamspace_id = teamspace.id
 
         api_arguments = api_arguments or {}
@@ -166,20 +159,32 @@ class AIHub:
             project_id=teamspace_id,
             name=name,
             api_arguments=api_arguments,
+            machine=machine,
+            quantity=quantity,
         )
+
         url = (
             quote(
-                f"{LIGHTNING_CLOUD_URL}/{teamspace._org.name}/{teamspace.name}/jobs/{deployment.name}",
+                f"{_get_cloud_url}/{teamspace.owner.name}/{teamspace.name}/jobs/{deployment.name}",
                 safe=":/()",
             )
             + "?app_id=deployment"
         )
+
         print("Deployment available at:", url)
 
-        return {
-            "id": deployment.id,
-            "name": deployment.name,
-            "deployment_url": url,
-            "api_endpoint": deployment.status.urls[0],
-            "interruptible": deployment.spec.spot,
-        }
+        return deployment
+
+    def delete_deployment(self, deployment: V1Deployment) -> None:
+        """Delete a deployment from the AI Hub.
+
+        Example:
+            from lightning_sdk import AIHub
+            hub = AIHub()
+            deployment = hub.run("temp_xxxx")
+            hub.delete_deployment(deployment)
+
+        Args:
+            deployment: The deployment object returned by the run method.
+        """
+        self._api.delete_api(deployment.id, deployment.project_id)

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/ai_hub_api.py

@@ -1,8 +1,11 @@
 import traceback
-from typing import Dict, List, Optional, Tuple
+import warnings
+from typing import Dict, List, Optional, Tuple, Union
 
 import backoff
 
+from lightning_sdk.api.deployment_api import apply_change
+from lightning_sdk.api.utils import _machine_to_compute_name
 from lightning_sdk.lightning_cloud.openapi.models import (
     CreateDeploymentRequestDefinesASpecForTheJobThatAllowsForAutoscalingJobs,
     V1Deployment,
@@ -16,6 +19,7 @@ from lightning_sdk.lightning_cloud.openapi.models.v1_deployment_template_gallery
     V1DeploymentTemplateGalleryResponse,
 )
 from lightning_sdk.lightning_cloud.rest_client import LightningClient
+from lightning_sdk.machine import Machine
 
 
 class AIHubApi:
@@ -92,15 +96,17 @@ class AIHubApi:
 
                 if p.type == V1DeploymentTemplateParameterType.CHECKBOX and p.checkbox:
                     api_arguments[p.name] = (
-                        (p.checkbox.true_value or "True")
-                        if p.checkbox.is_checked
-                        else (p.checkbox.false_value or "False")
+                        (p.checkbox.true_value or "") if p.checkbox.is_checked else (p.checkbox.false_value or "")
                     )
 
         for p in parameters:
             name = p.name
             pattern = f"${{{name}}}"
             if name in api_arguments:
+                if p.type == V1DeploymentTemplateParameterType.CHECKBOX and p.checkbox:
+                    api_arguments[p.name] = (
+                        (p.checkbox.true_value or "") if api_arguments[name] is True else (p.checkbox.false_value or "")
+                    )
                 AIHubApi._update_parameters(job, p.placements, pattern, api_arguments[name])
             elif not p.required:
                 AIHubApi._update_parameters(job, p.placements, pattern, "")
@@ -110,13 +116,46 @@ class AIHubApi:
         return job
 
     def run_api(
-        self, template_id: str, project_id: str, cloud_account: str, name: Optional[str], api_arguments: Dict[str, str]
+        self,
+        template_id: str,
+        project_id: str,
+        cloud_account: str,
+        name: Optional[str],
+        api_arguments: Dict[str, str],
+        machine: Optional[Union[str, Machine]],
+        quantity: Optional[int],
     ) -> V1Deployment:
         template = self._client.deployment_templates_service_get_deployment_template(template_id)
         name = name or template.name
         template.spec_v2.endpoint.id = None
 
+        # These are needed to ensure templates with a max replicas of 0 will start on creation
+        if template.spec_v2.autoscaling.max_replicas == "0":
+            template.spec_v2.autoscaling.max_replicas = "1"
+        if not template.spec_v2.autoscaling.enabled:
+            template.spec_v2.autoscaling.enabled = True
+
         AIHubApi._set_parameters(template.spec_v2.job, template.parameter_spec.parameters, api_arguments)
+        if machine and isinstance(machine, Machine):
+            apply_change(template.spec_v2.job, "instance_name", _machine_to_compute_name(machine))
+            apply_change(template.spec_v2.job, "instance_type", _machine_to_compute_name(machine))
+        elif machine and isinstance(machine, str):
+            apply_change(template.spec_v2.job, "instance_name", machine)
+            apply_change(template.spec_v2.job, "instance_type", machine)
+
+        if quantity != template.spec_v2.job.quantity:
+            # If the quantity is different from the published template quantity, override it with warnging
+            warnings.warn(
+                "Overriding the quantity of the template with the provided quantity. "
+                "This may result in unexpected behavior. "
+                f"Please verify the template (https://lightning.ai/lightning-ai/ai-hub/{template_id}) "
+                "and asscoiated parameters before running."
+            )
+            apply_change(template.spec_v2.job, "quantity", quantity)
+
+        # Override the cluster_id with the cloud_account if it is provided
+        if len(cloud_account) > 0:
+            apply_change(template.spec_v2.job, "cluster_id", cloud_account)
         return self._client.jobs_service_create_deployment(
             project_id=project_id,
             body=CreateDeploymentRequestDefinesASpecForTheJobThatAllowsForAutoscalingJobs(
@@ -124,7 +163,11 @@ class AIHubApi:
                 cluster_id=cloud_account,
                 endpoint=template.spec_v2.endpoint,
                 name=name,
-                replicas=0,
+                replicas=1,
                 spec=template.spec_v2.job,
+                parent_template_id=template_id,
             ),
         )
+
+    def delete_api(self, deployment_id: str, teamspace_id: str) -> None:
+        self._client.jobs_service_delete_deployment(project_id=teamspace_id, id=deployment_id)

lightning_sdk/api/base_studio_api.py

@@ -0,0 +1,90 @@
+from typing import Any, List, Optional
+
+from lightning_sdk.lightning_cloud.openapi import (
+    V1CloudSpaceEnvironmentType,
+    V1ListCloudSpaceEnvironmentTemplatesResponse,
+)
+from lightning_sdk.lightning_cloud.openapi.models.update import Update as BaseStudioUpdateBody
+from lightning_sdk.lightning_cloud.openapi.models.v1_cloud_space_environment_template import (
+    V1CloudSpaceEnvironmentTemplate,
+)
+from lightning_sdk.lightning_cloud.rest_client import LightningClient
+
+
+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: 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 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: Optional[str]) -> V1ListCloudSpaceEnvironmentTemplatesResponse:
+        """Retrieve all base studios for a given organization."""
+        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,
+        base_studio_id: str,
+        org_id: str,
+        name: Optional[str] = None,
+        allowed_machines: Optional[List[str]] = None,
+        default_machine: Optional[str] = None,
+        disabled: Optional[bool] = None,
+        environment_type: Optional[V1CloudSpaceEnvironmentType] = None,
+        machine_image_version: Optional[str] = None,
+        setup_script_text: Optional[str] = None,
+    ) -> V1CloudSpaceEnvironmentTemplate:
+        base_studio = self.get_base_studio(base_studio_id, org_id)
+
+        # Get the current configuration for the base studio
+        update_body = BaseStudioUpdateBody(
+            org_id=base_studio.org_id,
+            name=base_studio.name,
+            allowed_machines=base_studio.config.allowed_machines,
+            default_machine=base_studio.config.default_machine,
+            environment_type=base_studio.config.environment_type,
+            machine_image_version=base_studio.config.machine_image_version,
+            setup_script_text=base_studio.config.setup_script_text,
+            disabled=base_studio.disabled,
+        )
+
+        # Apply changes only if the new value is not None
+        apply_change(update_body, "name", name)
+        apply_change(update_body, "allowed_machines", allowed_machines)
+        apply_change(update_body, "default_machine", default_machine)
+        apply_change(update_body, "environment_type", environment_type)
+        apply_change(update_body, "machine_image_version", machine_image_version)
+        apply_change(update_body, "setup_script_text", setup_script_text)
+        apply_change(update_body, "disabled", disabled)
+
+        return self._client.cloud_space_environment_template_service_update_cloud_space_environment_template(
+            id=base_studio_id,
+            body=update_body,
+        )
+
+
+def apply_change(spec: Any, key: str, value: Any) -> bool:
+    if value is None:
+        return False
+
+    if getattr(spec, key) != value:
+        setattr(spec, key, value)
+        return True
+
+    return False

lightning_sdk/api/cloud_account_api.py

@@ -0,0 +1,225 @@
+from functools import lru_cache
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+from lightning_sdk.lightning_cloud.openapi import (
+    Externalv1Cluster,
+    V1CloudProvider,
+    V1ClusterType,
+    V1ExternalCluster,
+    V1ListClusterAcceleratorsResponse,
+    V1ListDefaultClusterAcceleratorsResponse,
+)
+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:
+    """Internal API client for API requests to cluster endpoints."""
+
+    def __init__(self) -> None:
+        self._client = LightningClient(max_tries=7)
+
+    def get_cloud_account(self, cloud_account_id: str, teamspace_id: str, org_id: str) -> Externalv1Cluster:
+        """Gets the cluster from given params cluster_id, project_id and owner.
+
+        Args:
+            cloud_account_id: the cloud account to get
+            teamspace_id: the teamspace the cloud_account is supposed to be associated with
+            org_id: The owning org of this teamspace
+
+        """
+        res = self._client.cluster_service_get_cluster(id=cloud_account_id, org_id=org_id, project_id=teamspace_id)
+        if not res:
+            raise ValueError(f"CloudAccount {cloud_account_id} does not exist")
+        return res
+
+    @lru_cache(maxsize=None)  # noqa: B019
+    def list_cloud_accounts(self, teamspace_id: str) -> List[V1ExternalCluster]:
+        """Lists the cloud accounts for a given teamspace.
+
+        Args:
+            teamspace_id: The teamspace to list cloud accounts for
+
+        Returns:
+            A list of cloud accounts
+        """
+        res_project = self._client.cluster_service_list_project_clusters(
+            project_id=teamspace_id,
+        )
+        res_global = self._client.cluster_service_list_clusters(
+            project_id=teamspace_id,
+        )
+
+        # can't use set here because the cloud_accounts are not hashable
+        cloud_accounts = []
+        cloud_account_ids = []
+        for cloud_account in res_project.clusters + res_global.clusters:
+            if cloud_account.id not in cloud_account_ids:
+                cloud_accounts.append(cloud_account)
+                cloud_account_ids.append(cloud_account.id)
+
+        return cloud_accounts
+
+    def get_cloud_account_non_org(self, teamspace_id: str, cloud_account_id: str) -> Optional[V1ExternalCluster]:
+        for cluster in self.list_cloud_accounts(teamspace_id=teamspace_id):
+            if cluster.id == cloud_account_id:
+                return cluster
+
+        return None
+
+    @lru_cache(maxsize=None)  # noqa: B019
+    def list_cloud_account_accelerators(
+        self,
+        teamspace_id: str,
+        cloud_account_id: str,
+        org_id: str,
+    ) -> Union[V1ListClusterAcceleratorsResponse, V1ListDefaultClusterAcceleratorsResponse]:
+        """Lists the accelerators for a given cloud account.
+
+        Args:
+            cloud_account_id: cluster ID to list accelerators for
+        """
+        # map cloud_account to provider
+        cloud_provider = None
+        is_default = True
+        for cloud_account in self.list_cloud_accounts(teamspace_id=teamspace_id):
+            if cloud_account.id == cloud_account_id:
+                is_default = cloud_account.spec.cluster_type == V1ClusterType.GLOBAL
+                cloud_provider = self._get_cloud_account_provider(cloud_account)
+                break
+
+        if cloud_provider is None:
+            raise ValueError(
+                f"Cloud Account {cloud_account_id} is not a default cloud account. Are you in the correct teamspace?"
+            )
+
+        if is_default:
+            res = self._list_default_cluster_accelerators(teamspace_id=teamspace_id, cloud_provider=cloud_provider)
+        else:
+            res = self._client.cluster_service_list_cluster_accelerators(
+                id=cloud_account_id,
+                org_id=org_id,
+            )
+
+        if not res:
+            raise ValueError(f"CloudAccount {cloud_account_id} does not exist")
+        return res
+
+    def _list_default_cluster_accelerators(
+        self, teamspace_id: str, cloud_provider: Union[str, "CloudProvider"]
+    ) -> V1ListDefaultClusterAcceleratorsResponse:
+        return self._client.cluster_service_list_default_cluster_accelerators(
+            project_id=teamspace_id, cloud_provider=str(cloud_provider)
+        )
+
+    @lru_cache(maxsize=None)  # noqa: B019
+    def list_global_cloud_accounts(self, teamspace_id: str) -> List[V1ExternalCluster]:
+        """Lists the accelerators for a given teamspace.
+
+        Args:
+            teamspace_id: id of the teamspace to get the associated cloud_accounts for
+        """
+        cloud_accounts = self.list_cloud_accounts(teamspace_id=teamspace_id)
+        if not cloud_accounts:
+            raise ValueError(f"Teamspace {teamspace_id} does not exist")
+        filtered_cloud_accounts = filter(lambda x: x.spec.cluster_type == V1ClusterType.GLOBAL, cloud_accounts)
+        # TODO: remove aggregate filter once finished
+        filtered_cloud_accounts = filter(
+            lambda x: x.spec.driver != V1CloudProvider.LIGHTNING_AGGREGATE, filtered_cloud_accounts
+        )
+        return list(filtered_cloud_accounts)
+
+    def get_cloud_account_provider_mapping(self, teamspace_id: str) -> Dict["CloudProvider", V1ExternalCluster]:
+        """Gets the cloud account <-> provider mapping."""
+        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]) -> Optional["CloudProvider"]:
+        """Determines the cloud provider based on the cloud_account configuration.
+
+        Args:
+            cloud_account: An optional Externalv1Cluster object containing cluster specifications
+
+        Returns:
+            CloudProvider: The determined cloud provider, defaults to AWS if no match is found
+        """
+        from lightning_sdk.machine import CloudProvider
+
+        if not cloud_account:
+            return CloudProvider.AWS
+
+        if cloud_account.spec and cloud_account.spec.driver:
+            if cloud_account.spec.driver == V1CloudProvider.LIGHTNING:
+                return CloudProvider.LIGHTNING
+
+            if cloud_account.spec.driver == V1CloudProvider.DGX:
+                return CloudProvider.DGX
+
+        if cloud_account.spec:
+            if cloud_account.spec.aws_v1:
+                return CloudProvider.AWS
+            if cloud_account.spec.google_cloud_v1:
+                return CloudProvider.GCP
+            if cloud_account.spec.lambda_labs_v1:
+                return CloudProvider.LAMBDA_LABS
+            if cloud_account.spec.voltage_park_v1:
+                return CloudProvider.VOLTAGE_PARK
+            if cloud_account.spec.nebius_v1:
+                return CloudProvider.NEBIUS
+
+        return None
+
+    def resolve_cloud_account(
+        self,
+        teamspace_id: str,
+        cloud_account: Optional[str],
+        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} "
+                        f"has cloud provider {cloud_provider_resp}) which don't match!"
+                    )
+
+            return cloud_account
+
+        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].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!")