lightning-sdk 0.1.2__py3-none-any.whl → 0.1.46__py3-none-any.whl

lightning_sdk/cli/download.py

@@ -0,0 +1,132 @@
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+from lightning_sdk.cli.exceptions import StudioCliError
+from lightning_sdk.cli.studios_menu import _StudiosMenu
+from lightning_sdk.models import download_model
+from lightning_sdk.studio import Studio
+from lightning_sdk.utils.resolve import _get_authed_user, skip_studio_init
+
+
+class _Downloads(_StudiosMenu):
+    """Download files and folders from Lightning AI."""
+
+    def model(self, name: str, download_dir: str = ".") -> None:
+        """Download a Model.
+
+        Args:
+          name: The name of the Model you want to download.
+            This should have the format <ORGANIZATION-NAME>/<TEAMSPACE-NAME>/<MODEL-NAME>.
+          download_dir: The directory where the Model should be downloaded.
+        """
+        download_model(
+            name=name,
+            download_dir=download_dir,
+            progress_bar=True,
+        )
+
+    def _resolve_studio(self, studio: Optional[str]) -> Studio:
+        user = _get_authed_user()
+        # if no studio specify suggest/filter only user's studios
+        possible_studios = self._get_possible_studios(user, is_owner=studio is None)
+
+        try:
+            if studio:
+                team_name, studio_name = studio.split("/")
+                options = [st for st in possible_studios if st["teamspace"] == team_name and st["name"] == studio_name]
+                if len(options) == 1:
+                    selected_studio = self._get_studio_from_name(studio, possible_studios)
+                # user can also use the partial studio name as secondary interactive selection
+                else:
+                    # filter matching simple reg expressions or start with the team and studio name
+                    possible_studios = filter(
+                        lambda st: (re.match(team_name, st["teamspace"]) or team_name in st["teamspace"])
+                        and (re.match(studio_name, st["name"]) or studio_name in st["name"]),
+                        possible_studios,
+                    )
+                    if not possible_studios:
+                        raise ValueError(
+                            f"Could not find Studio like '{studio}', please consider update your filtering pattern."
+                        )
+                    selected_studio = self._get_studio_from_interactive_menu(list(possible_studios))
+            else:
+                selected_studio = self._get_studio_from_interactive_menu(possible_studios)
+
+        except KeyboardInterrupt:
+            raise KeyboardInterrupt from None
+
+        # give user friendlier error message
+        except Exception as e:
+            raise StudioCliError(
+                f"Could not find the given Studio {studio} to upload files to. "
+                "Please contact Lightning AI directly to resolve this issue."
+            ) from e
+
+        with skip_studio_init():
+            return Studio(**selected_studio)
+
+    def folder(self, path: str = "", studio: Optional[str] = None, local_path: str = ".") -> None:
+        """Download a folder from a Studio.
+
+        Args:
+          path: The relative path within the Studio you want to download.
+            If you leave it empty it will download whole studio and locally creates a new folder
+            with the same name as the selected studio.
+          studio: The name of the studio to upload to. Will show a menu with user's owned studios for selection
+            if not specified. If provided, should be in the form of <TEAMSPACE-NAME>/<STUDIO-NAME> where the names
+            are case-sensitive. The teamspace and studio names can be regular expressions to match, then a menu
+            with filtered studios will be shown for final selection.
+          local_path: The path to the directory you want to download the folder to.
+        """
+        local_path = Path(local_path)
+        if not local_path.is_dir():
+            raise NotADirectoryError(f"'{local_path}' is not a directory")
+
+        resolved_studio = self._resolve_studio(studio)
+
+        if not path:
+            local_path /= resolved_studio.name
+            path = ""
+
+        try:
+            if not path:
+                raise FileNotFoundError()
+            resolved_studio.download_folder(remote_path=path, target_path=str(local_path))
+        except Exception as e:
+            raise StudioCliError(
+                f"Could not download the folder from the given Studio {studio}. "
+                "Please contact Lightning AI directly to resolve this issue."
+            ) from e
+
+    def file(self, path: str = "", studio: Optional[str] = None, local_path: str = ".") -> None:
+        """Download a file from a Studio.
+
+        Args:
+          path: The relative path within the Studio you want to download.
+          studio: The name of the studio to upload to. Will show a menu with user's owned studios for selection
+            if not specified. If provided, should be in the form of <TEAMSPACE-NAME>/<STUDIO-NAME> where the names
+            are case-sensitive. The teamspace and studio names can be regular expressions to match, then a menu
+            with filtered studios will be shown for final selection.
+          local_path: The path to the directory you want to download the file to.
+        """
+        local_path = Path(local_path)
+        if not local_path.is_dir():
+            raise NotADirectoryError(f"'{local_path}' is not a directory")
+
+        resolved_studio = self._resolve_studio(studio)
+
+        if not path:
+            local_path /= resolved_studio.name
+            path = ""
+
+        try:
+            if not path:
+                raise FileNotFoundError()
+            resolved_studio.download_file(remote_path=path, file_path=str(local_path / os.path.basename(path)))
+        except Exception as e:
+            raise StudioCliError(
+                f"Could not download the file from the given Studio {studio}. "
+                "Please contact Lightning AI directly to resolve this issue."
+            ) from e

lightning_sdk/cli/entrypoint.py

@@ -2,19 +2,27 @@ from fire import Fire
 from lightning_utilities.core.imports import RequirementCache
 
 from lightning_sdk.api.studio_api import _cloud_url
+from lightning_sdk.cli.ai_hub import _AIHub
+from lightning_sdk.cli.download import _Downloads
 from lightning_sdk.cli.legacy import _LegacyLightningCLI
+from lightning_sdk.cli.run import _Run
+from lightning_sdk.cli.serve import _Docker, _LitServe
 from lightning_sdk.cli.upload import _Uploads
 from lightning_sdk.lightning_cloud.login import Auth
 
 _LIGHTNING_AVAILABLE = RequirementCache("lightning")
 
 
-class StudioCLI(_Uploads):
+class StudioCLI:
     """Command line interface (CLI) to interact with/manage Lightning AI Studios."""
 
     def __init__(self) -> None:
-        if _LIGHTNING_AVAILABLE:
-            self.run = _LegacyLightningCLI()
+        self.download = _Downloads()
+        self.upload = _Uploads()
+        self.aihub = _AIHub()
+        self.run = _Run(legacy_run=_LegacyLightningCLI() if _LIGHTNING_AVAILABLE else None)
+        self.serve = _LitServe()
+        self.dockerize = _Docker()
 
     def login(self) -> None:
         """Login to Lightning AI Studios."""

lightning_sdk/cli/run.py

@@ -0,0 +1,206 @@
+from typing import TYPE_CHECKING, Dict, Optional
+
+from lightning_sdk.job import Job
+from lightning_sdk.machine import Machine
+from lightning_sdk.mmt import MMT
+from lightning_sdk.teamspace import Teamspace
+
+if TYPE_CHECKING:
+    from lightning_sdk.cli.legacy import _LegacyLightningCLI
+
+_MACHINE_VALUES = tuple([machine.value for machine in Machine])
+
+
+class _Run:
+    """Run async workloads on the Lightning AI platform."""
+
+    def __init__(self, legacy_run: Optional["_LegacyLightningCLI"] = None) -> None:
+        if legacy_run is not None:
+            self.app = legacy_run.app
+            self.model = legacy_run.model
+
+        # Need to set the docstring here for f-strings to work.
+        # Sadly this is the only way to really show options as f-strings are not allowed as docstrings directly
+        # and fire does not show values for literals, just that it is a literal.
+        docstr_job = f"""Run async workloads using a docker image or a compute environment from your studio.
+
+        Args:
+            name: The name of the job. Needs to be unique within the teamspace.
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}.
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            teamspace: The teamspace the job should be associated with. Defaults to the current teamspace.
+            org: The organization owning the teamspace (if any). Defaults to the current organization.
+            user: The user owning the teamspace (if any). Defaults to the current user.
+            cloud_account: The cloud account to run the job on.
+                Defaults to the studio cloud account if running with studio compute env.
+                If not provided will fall back to the teamspaces default cloud account.
+            env: Environment variables to set inside the job.
+            interruptible: Whether the job should run on interruptible instances. They are cheaper but can be preempted.
+            image_credentials: The credentials used to pull the image. Required if the image is private.
+                This should be the name of the respective credentials secret created on the Lightning AI platform.
+            cloud_account_auth: Whether to authenticate with the cloud account to pull the image.
+                Required if the registry is part of a cloud provider (e.g. ECR).
+            artifacts_local: The path of inside the docker container, you want to persist images from.
+                CAUTION: When setting this to "/", it will effectively erase your container.
+                Only supported for jobs with a docker image compute environment.
+            artifacts_remote: The remote storage to persist your artifacts to.
+                Should be of format <CONNECTION_TYPE>:<CONNECTION_NAME>:<PATH_WITHIN_CONNECTION>.
+                PATH_WITHIN_CONNECTION hereby is a path relative to the connection's root.
+                E.g. efs:data:some-path would result in an EFS connection named `data` and to the path `some-path`
+                within it.
+                Note that the connection needs to be added to the teamspace already in order for it to be found.
+                Only supported for jobs with a docker image compute environment.
+        """
+        # TODO: the docstrings from artifacts_local and artifacts_remote don't show up completely,
+        # might need to switch to explicit cli definition
+        self.job.__func__.__doc__ = docstr_job
+
+        # Need to set the docstring here for f-strings to work.
+        # Sadly this is the only way to really show options as f-strings are not allowed as docstrings directly
+        # and fire does not show values for literals, just that it is a literal.
+        docstr_mmt = f"""Run async workloads on multiple machines using a docker image.
+
+        Args:
+            name: The name of the job. Needs to be unique within the teamspace.
+            num_machines: The number of Machines to run on. Defaults to 2 Machines
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}. Defaults to CPU
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            teamspace: The teamspace the job should be associated with. Defaults to the current teamspace.
+            org: The organization owning the teamspace (if any). Defaults to the current organization.
+            user: The user owning the teamspace (if any). Defaults to the current user.
+            cloud_account: The cloud account to run the job on.
+                Defaults to the studio cloud account if running with studio compute env.
+                If not provided will fall back to the teamspaces default cloud account.
+            env: Environment variables to set inside the job.
+            interruptible: Whether the job should run on interruptible instances. They are cheaper but can be preempted.
+            image_credentials: The credentials used to pull the image. Required if the image is private.
+                This should be the name of the respective credentials secret created on the Lightning AI platform.
+            cloud_account_auth: Whether to authenticate with the cloud account to pull the image.
+                Required if the registry is part of a cloud provider (e.g. ECR).
+            artifacts_local: The path of inside the docker container, you want to persist images from.
+                CAUTION: When setting this to "/", it will effectively erase your container.
+                Only supported for jobs with a docker image compute environment.
+            artifacts_remote: The remote storage to persist your artifacts to.
+                Should be of format <CONNECTION_TYPE>:<CONNECTION_NAME>:<PATH_WITHIN_CONNECTION>.
+                PATH_WITHIN_CONNECTION hereby is a path relative to the connection's root.
+                E.g. efs:data:some-path would result in an EFS connection named `data` and to the path `some-path`
+                within it.
+                Note that the connection needs to be added to the teamspace already in order for it to be found.
+                Only supported for jobs with a docker image compute environment.
+        """
+        # TODO: the docstrings from artifacts_local and artifacts_remote don't show up completely,
+        # might need to switch to explicit cli definition
+        self.mmt.__func__.__doc__ = docstr_mmt
+
+    # TODO: sadly, fire displays both Optional[type] and Union[type, None] as Optional[Optional]
+    # see https://github.com/google/python-fire/pull/513
+    # might need to move to different cli library
+    def job(
+        self,
+        name: str,
+        machine: Optional[str] = None,
+        command: Optional[str] = None,
+        studio: Optional[str] = None,
+        image: Optional[str] = None,
+        teamspace: Optional[str] = None,
+        org: Optional[str] = None,
+        user: Optional[str] = None,
+        cloud_account: Optional[str] = None,
+        env: Optional[Dict[str, str]] = None,
+        interruptible: bool = False,
+        image_credentials: Optional[str] = None,
+        cloud_account_auth: bool = False,
+        artifacts_local: Optional[str] = None,
+        artifacts_remote: Optional[str] = None,
+    ) -> None:
+        if machine is None:
+            # TODO: infer from studio
+            machine = "CPU"
+        machine_enum = Machine(machine.upper())
+
+        resolved_teamspace = Teamspace(name=teamspace, org=org, user=user)
+
+        if cloud_account is None:
+            cloud_account = resolved_teamspace.default_cloud_account
+        machine_enum = Machine(machine.upper())
+        Job.run(
+            name=name,
+            machine=machine_enum,
+            command=command,
+            studio=studio,
+            image=image,
+            teamspace=resolved_teamspace,
+            org=org,
+            user=user,
+            cloud_account=cloud_account,
+            env=env,
+            interruptible=interruptible,
+            image_credentials=image_credentials,
+            cloud_account_auth=cloud_account_auth,
+            artifacts_local=artifacts_local,
+            artifacts_remote=artifacts_remote,
+        )
+
+    # TODO: sadly, fire displays both Optional[type] and Union[type, None] as Optional[Optional]
+    # see https://github.com/google/python-fire/pull/513
+    # might need to move to different cli library
+    def mmt(
+        self,
+        name: Optional[str] = None,
+        num_machines: int = 2,
+        machine: Optional[str] = None,
+        command: Optional[str] = None,
+        image: Optional[str] = None,
+        teamspace: Optional[str] = None,
+        org: Optional[str] = None,
+        user: Optional[str] = None,
+        cloud_account: Optional[str] = None,
+        env: Optional[Dict[str, str]] = None,
+        interruptible: bool = False,
+        image_credentials: Optional[str] = None,
+        cloud_account_auth: bool = False,
+        artifacts_local: Optional[str] = None,
+        artifacts_remote: Optional[str] = None,
+    ) -> None:
+        if name is None:
+            from datetime import datetime
+
+            timestr = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+            name = f"mmt-{timestr}"
+
+        if machine is None:
+            # TODO: infer from studio
+            machine = "CPU"
+        machine_enum = Machine(machine.upper())
+
+        resolved_teamspace = Teamspace(name=teamspace, org=org, user=user)
+        if cloud_account is None:
+            cloud_account = resolved_teamspace.default_cloud_account
+
+        if image is None:
+            raise RuntimeError("Image needs to be specified to run a multi-machine job")
+
+        MMT.run(
+            name=name,
+            num_machines=num_machines,
+            machine=machine_enum,
+            command=command,
+            studio=None,
+            image=image,
+            teamspace=resolved_teamspace,
+            org=org,
+            user=user,
+            cloud_account=cloud_account,
+            env=env,
+            interruptible=interruptible,
+            image_credentials=image_credentials,
+            cloud_account_auth=cloud_account_auth,
+            artifacts_local=artifacts_local,
+            artifacts_remote=artifacts_remote,
+        )

lightning_sdk/cli/serve.py

@@ -0,0 +1,218 @@
+import os
+import subprocess
+import warnings
+from pathlib import Path
+from typing import Optional, Union
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.prompt import Confirm
+
+
+class _LitServe:
+    """Serve a LitServe model.
+
+    Example:
+        lightning serve api server.py  # serve locally
+        lightning serve api server.py --cloud  # deploy to the cloud
+
+    You can deploy the API to the cloud by running `lightning serve api server.py --cloud`.
+    This will generate a Dockerfile, build the image, and push it to the image registry.
+    Deploying to the cloud requires pre-login to the docker registry.
+    """
+
+    def api(
+        self,
+        script_path: Union[str, Path],
+        easy: bool = False,
+        cloud: bool = False,
+        repository: Optional[str] = None,
+        non_interactive: bool = False,
+    ) -> None:
+        """Deploy a LitServe model script.
+
+        Args:
+            script_path: Path to the script to serve
+            easy: If True, generates a client for the model
+            cloud: If True, deploy the model to the Lightning Studio
+            repository: Optional Docker repository name (e.g., 'username/model-name')
+            non_interactive: If True, do not prompt for confirmation
+        Raises:
+            FileNotFoundError: If script_path doesn't exist
+            ImportError: If litserve is not installed
+            subprocess.CalledProcessError: If the script fails to run
+            IOError: If client.py generation fails
+        """
+        console = Console()
+        script_path = Path(script_path)
+        if not script_path.exists():
+            raise FileNotFoundError(f"Script not found: {script_path}")
+        if not script_path.is_file():
+            raise ValueError(f"Path is not a file: {script_path}")
+
+        try:
+            from litserve.python_client import client_template
+        except ImportError:
+            raise ImportError(
+                "litserve is not installed. Please install it with `pip install lightning_sdk[serve]`"
+            ) from None
+
+        if easy:
+            client_path = Path("client.py")
+            if client_path.exists():
+                console.print("Skipping client generation: client.py already exists", style="blue")
+            else:
+                try:
+                    client_path.write_text(client_template)
+                    console.print("✅ Client generated at client.py", style="bold green")
+                except OSError as e:
+                    raise OSError(f"Failed to generate client.py: {e!s}") from None
+
+        if cloud:
+            tag = repository if repository else "litserve-model"
+            return self._handle_cloud(script_path, console, tag=tag, non_interactive=non_interactive)
+
+        try:
+            subprocess.run(
+                ["python", str(script_path)],
+                check=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            error_msg = f"Script execution failed with exit code {e.returncode}\nstdout: {e.stdout}\nstderr: {e.stderr}"
+            raise RuntimeError(error_msg) from None
+
+    def _handle_cloud(
+        self,
+        script_path: Union[str, Path],
+        console: Console,
+        tag: str = "litserve-model",
+        non_interactive: bool = False,
+    ) -> None:
+        try:
+            import docker
+        except ImportError:
+            raise ImportError("docker-py is not installed. Please install it with `pip install docker`") from None
+
+        try:
+            client = docker.from_env()
+            client.ping()
+        except docker.errors.DockerException as e:
+            raise RuntimeError(f"Failed to connect to Docker daemon: {e!s}. Is Docker running?") from None
+
+        dockerizer = _Docker()
+        path = dockerizer.api(script_path, port=8000, gpu=False, tag=tag)
+
+        console.clear()
+        if non_interactive:
+            console.print("[italic]non-interactive[/italic] mode enabled, skipping confirmation prompts", style="blue")
+
+        console.print(f"\nPlease review the Dockerfile at [u]{path}[/u] and make sure it is correct.", style="bold")
+        correct_dockerfile = True if non_interactive else Confirm.ask("Is the Dockerfile correct?", default=True)
+        if not correct_dockerfile:
+            console.print("Please fix the Dockerfile and try again.", style="red")
+            return
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            TimeElapsedColumn(),
+            console=console,
+            transient=False,
+        ) as progress:
+            build_task = progress.add_task("Building Docker image", total=None)
+            build_status = client.api.build(
+                path=os.path.dirname(path), dockerfile=path, tag=tag, decode=True, quiet=False
+            )
+            for line in build_status:
+                if "error" in line:
+                    progress.stop()
+                    console.print(f"\n[red]{line}[/red]")
+                    return
+                if "stream" in line and line["stream"].strip():
+                    console.print(line["stream"].strip(), style="bright_black")
+                    progress.update(build_task, description="Building Docker image")
+
+            progress.update(build_task, description="[green]Build completed![/green]")
+
+            push_task = progress.add_task("Pushing to registry", total=None)
+            console.print("\nPushing image...", style="bold blue")
+            push_status = client.api.push(tag, stream=True, decode=True)
+            for line in push_status:
+                if "error" in line:
+                    progress.stop()
+                    console.print(f"\n[red]{line}[/red]")
+                    return
+                if "status" in line:
+                    console.print(line["status"], style="bright_black")
+                    progress.update(push_task, description="Pushing to registry")
+
+            progress.update(push_task, description="[green]Push completed![/green]")
+
+        console.print(f"\n✅ Image pushed to {tag}", style="bold green")
+        console.print(
+            "Soon you will be able to deploy this model to the Lightning Studio!",
+        )
+        # TODO: Deploy to the cloud
+
+
+class _Docker:
+    """Generate a Dockerfile for a LitServe model."""
+
+    def api(self, server_filename: str, port: int = 8000, gpu: bool = False, tag: str = "litserve-model") -> str:
+        """Generate a Dockerfile for the given server code.
+
+        Args:
+            server_filename: The path to the server file. Example sever.py or app.py.
+            port: The port to expose in the Docker container.
+            gpu: Whether to use a GPU-enabled Docker image.
+            tag: Docker image tag to use in examples.
+        """
+        import litserve as ls
+        from litserve import docker_builder
+
+        console = Console()
+        requirements = ""
+        if os.path.exists("requirements.txt"):
+            requirements = "-r requirements.txt"
+        else:
+            warnings.warn(
+                f"requirements.txt not found at {os.getcwd()}. "
+                f"Make sure to install the required packages in the Dockerfile.",
+                UserWarning,
+            )
+
+        current_dir = Path.cwd()
+        if not (current_dir / server_filename).is_file():
+            raise FileNotFoundError(f"Server file `{server_filename}` must be in the current directory: {os.getcwd()}")
+
+        version = ls.__version__
+        if gpu:
+            run_cmd = f"docker run --gpus all -p {port}:{port} {tag}:latest"
+            docker_template = docker_builder.CUDA_DOCKER_TEMPLATE
+        else:
+            run_cmd = f"docker run -p {port}:{port} {tag}:latest"
+            docker_template = docker_builder.DOCKERFILE_TEMPLATE
+        dockerfile_content = docker_template.format(
+            server_filename=server_filename,
+            port=port,
+            version=version,
+            requirements=requirements,
+        )
+        with open("Dockerfile", "w") as f:
+            f.write(dockerfile_content)
+
+        success_msg = f"""[bold]Dockerfile created successfully[/bold]
+Update [underline]{os.path.abspath("Dockerfile")}[/underline] to add any additional dependencies or commands.
+
+[bold]Build the container with:[/bold]
+> [underline]docker build -t {tag} .[/underline]
+
+[bold]To run the Docker container on the machine:[/bold]
+> [underline]{run_cmd}[/underline]
+
+[bold]To push the container to a registry:[/bold]
+> [underline]docker push {tag}[/underline]
+"""
+        console.print(success_msg)
+        return os.path.abspath("Dockerfile")

lightning_sdk/cli/studios_menu.py

@@ -0,0 +1,78 @@
+from typing import Dict, List, Optional
+
+from simple_term_menu import TerminalMenu
+
+from lightning_sdk.api import OrgApi, TeamspaceApi
+from lightning_sdk.user import User
+
+
+class _StudiosMenu:
+    def _get_studio_from_interactive_menu(self, possible_studios: List[Dict[str, str]]) -> Dict[str, str]:
+        terminal_menu = self._prepare_terminal_menu_list_studios(possible_studios)
+        terminal_menu.show()
+        return possible_studios[terminal_menu.chosen_menu_index]
+
+    def _get_studio_from_name(self, studio: str, possible_studios: List[Dict[str, str]]) -> Dict[str, str]:
+        teamspace, name = studio.split("/", maxsplit=1)
+        for st in possible_studios:
+            if st["teamspace"] == teamspace and name == st["name"]:
+                return st
+
+        print("Could not find Studio {studio}, please select it from the list:")
+        return self._get_studio_from_interactive_menu(possible_studios)
+
+    @staticmethod
+    def _prepare_terminal_menu_list_studios(
+        possible_studios: List[Dict[str, str]], title: Optional[str] = None
+    ) -> TerminalMenu:
+        if title is None:
+            title = "Please select a Studio of the following studios:"
+
+        return TerminalMenu(
+            [f"{s['teamspace']}/{s['name']}" for s in possible_studios], title=title, clear_menu_on_exit=True
+        )
+
+    @staticmethod
+    def _get_possible_studios(user: User, is_owner: bool = True) -> List[Dict[str, str]]:
+        teamspace_api = TeamspaceApi()
+        org_api = OrgApi()
+        user_api = user._user_api
+        possible_studios = []
+
+        user_api._get_organizations_for_authed_user()
+        memberships = user_api._get_all_teamspace_memberships(user_id=user.id)
+
+        teamspaces = {}
+        # get all teamspace memberships
+        for membership in memberships:
+            teamspace_id = membership.project_id
+
+            if is_owner:
+                # get all studios for teamspace when user is owner
+                all_studios = user._user_api._get_cloudspaces_for_user(user_id=user.id, project_id=teamspace_id)
+            else:
+                all_studios = user._user_api._get_cloudspaces_for_user(project_id=teamspace_id)
+
+            for st in all_studios:
+                # populate teamspace info if necessary
+                if teamspace_id not in teamspaces:
+                    ts = teamspace_api._get_teamspace_by_id(teamspace_id)
+                    ts_name = ts.name
+
+                    # get organization if necessary
+                    if ts.owner_type == "organization":
+                        org_name = org_api._get_org_by_id(ts.owner_id).name
+                        user_name = None
+                    else:
+                        org_name = None
+
+                        # don't do a request if not necessary
+                        if ts.owner_id == user.id:
+                            user_name = user.name
+                        else:
+                            user_name = user_api._get_user_by_id(ts.owner_id).username
+
+                    teamspaces[teamspace_id] = {"user": user_name, "org": org_name, "teamspace": ts_name}
+                possible_studios.append({"name": st.name, **teamspaces[teamspace_id]})
+
+        return possible_studios