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

lightning_sdk/cli/legacy/create.py

@@ -0,0 +1,115 @@
+import random
+import string
+from contextlib import suppress
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from lightning_sdk import Machine, Studio
+from lightning_sdk.cli.utils.teamspace_selection import TeamspacesMenu
+from lightning_sdk.machine import CloudProvider
+
+_MACHINE_VALUES = tuple(
+    [machine.name for machine in Machine.__dict__.values() if isinstance(machine, Machine) and machine._include_in_cli]
+)
+_PROVIDER_VALUES = tuple([provider.value for provider in CloudProvider])
+
+
+@click.group("create")
+def create() -> None:
+    """Create new resources on the Lightning AI platform."""
+
+
+@create.command("studio")
+@click.argument("name")
+@click.option(
+    "--teamspace",
+    default=None,
+    help=(
+        "The teamspace the studio will be part of. "
+        "Should be of format <OWNER>/<TEAMSPACE_NAME>. "
+        "If not specified, tries to infer from the environment (e.g. when run from within a Studio.)"
+    ),
+)
+@click.option(
+    "--start",
+    default=None,
+    type=click.Choice(_MACHINE_VALUES),
+    help="If specified, will start the created studio on the given machine.",
+)
+@click.option(
+    "--cloud-account",
+    "--cloud_account",
+    default=None,
+    help=(
+        "The cloud account to create the studio on. "
+        "If not specified, will try to infer from the environment (e.g. when run from within a Studio.) "
+        "or fall back to the teamspace default."
+    ),
+)
+@click.option(
+    "--cloud-provider",
+    default=None,
+    type=click.Choice(_PROVIDER_VALUES),
+    help="The provider to create the studio on. If --cloud-account is specified, this option is prioritized.",
+)
+@click.option(
+    "--provider",
+    default=None,
+    type=click.Choice(_PROVIDER_VALUES),
+    help=(
+        "Deprecated. Use --cloud-provider instead. The provider to create the studio on. "
+        "If --cloud-account is specified, this option is prioritized."
+    ),
+)
+def studio(
+    name: str,
+    teamspace: Optional[str] = None,
+    start: Optional[str] = None,
+    cloud_account: Optional[str] = None,
+    cloud_provider: Optional[str] = None,
+    provider: Optional[str] = None,
+) -> None:
+    """Create a new studio on the Lightning AI platform.
+
+    Example:
+        lightning create studio NAME
+
+    NAME: the name of the studio to create. If already present within teamspace, will add a random suffix.
+    """
+    menu = TeamspacesMenu()
+    teamspace_resolved = menu(teamspace)
+
+    # default cloud account to current studios cloud account if run from studio
+    # else it will fall back to teamspace default in the backend
+    if cloud_account is None:
+        with suppress(ValueError):
+            s = Studio()
+            if s.teamspace.name == teamspace_resolved.name and s.teamspace.owner.name == teamspace_resolved.owner.name:
+                cloud_account = s.cloud_account
+
+    console = Console()
+
+    with suppress(ValueError):
+        Studio(name, teamspace=teamspace_resolved, create_ok=False)
+        new_name = name + "-" + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+        console.print(f"Studio with name {name} already exists. Using {new_name} instead.")
+        name = new_name
+
+    studio = Studio(
+        name=name,
+        teamspace=teamspace_resolved,
+        cloud_account=cloud_account,
+        create_ok=True,
+        cloud_provider=cloud_provider,
+        provider=provider,
+    )
+
+    console.print(f"Created Studio {studio.name}.")
+
+    if start is not None:
+        start_machine = getattr(Machine, start, start)
+        Studio.show_progress = True
+        studio.start(start_machine)
+        console.print(f"Started Studio {studio.name} on machine {start}")

lightning_sdk/cli/legacy/delete.py

@@ -0,0 +1,131 @@
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from lightning_sdk.cli.legacy.exceptions import StudioCliError
+from lightning_sdk.cli.legacy.job_and_mmt_action import _JobAndMMTAction
+from lightning_sdk.cli.utils.teamspace_selection import TeamspacesMenu
+from lightning_sdk.lightning_cloud.openapi.rest import ApiException
+from lightning_sdk.lit_container import LitContainer
+from lightning_sdk.studio import Studio
+
+
+@click.group()
+def delete() -> None:
+    """Delete resources on the Lightning AI platform."""
+
+
+@delete.command(name="container")
+@click.argument("name")
+@click.option(
+    "--teamspace",
+    default=None,
+    help=(
+        "The teamspace to delete the container from. "
+        "Should be specified as {owner}/{name} "
+        "If not provided, can be selected in an interactive menu."
+    ),
+)
+def container(name: str, teamspace: Optional[str] = None) -> None:
+    """Delete the docker container NAME."""
+    api = LitContainer()
+    menu = TeamspacesMenu()
+    resolved_teamspace = menu(teamspace=teamspace)
+    try:
+        api.delete_container(name, resolved_teamspace.name, resolved_teamspace.owner.name)
+        Console().print(f"Container {name} deleted successfully.")
+    except Exception as e:
+        raise StudioCliError(f"Could not delete container {name} from project {resolved_teamspace.name}: {e}") from None
+
+
+@delete.command(name="job")
+@click.argument(
+    "name",
+)
+@click.option(
+    "--teamspace",
+    default=None,
+    help=(
+        "The teamspace to delete the job from. "
+        "Should be specified as {owner}/{name} "
+        "If not provided, can be selected in an interactive menu."
+    ),
+)
+def job(name: Optional[str] = None, teamspace: Optional[str] = None) -> None:
+    """Delete a job.
+
+    Example:
+      lightning delete job NAME
+
+    NAME: the name of the job to delete.
+    """
+    menu = _JobAndMMTAction()
+    job = menu.job(name=name, teamspace=teamspace)
+
+    job.delete()
+    Console().print(f"Successfully deleted {job.name}!")
+
+
+@delete.command(name="mmt")
+@click.argument(
+    "name",
+)
+@click.option(
+    "--teamspace",
+    default=None,
+    help=(
+        "The teamspace to delete the job from. "
+        "Should be specified as {owner}/{name} "
+        "If not provided, can be selected in an interactive menu."
+    ),
+)
+def mmt(name: Optional[str] = None, teamspace: Optional[str] = None) -> None:
+    """Delete a multi-machine job.
+
+    Example:
+      lightning delete mmt NAME
+
+    NAME: the name of the multi-machine job to delete.
+    """
+    menu = _JobAndMMTAction()
+    mmt = menu.mmt(name=name, teamspace=teamspace)
+
+    mmt.delete()
+    Console().print(f"Successfully deleted {mmt.name}!")
+
+
+@delete.command(name="studio")
+@click.argument("name")
+@click.option(
+    "--teamspace",
+    default=None,
+    help=(
+        "The teamspace to delete the studio from. "
+        "Should be specified as {owner}/{name} "
+        "If not provided, can be selected in an interactive menu."
+    ),
+)
+def studio(name: str, teamspace: Optional[str] = None) -> None:
+    """Delete an existing studio.
+
+    Example:
+      lightning delete studio NAME
+
+    NAME: the name of the studio to delete
+    """
+    if teamspace is not None:
+        ts_splits = teamspace.split("/")
+        if len(ts_splits) != 2:
+            raise ValueError(f"Teamspace should be of format <OWNER>/<TEAMSPACE_NAME> but got {teamspace}")
+        owner, teamspace = ts_splits
+    else:
+        owner, teamspace = None, None
+
+    try:
+        studio = Studio(name=name, teamspace=teamspace, org=owner, user=None, create_ok=False)
+    except (RuntimeError, ValueError, ApiException):
+        studio = Studio(name=name, teamspace=teamspace, org=None, user=owner, create_ok=False)
+
+    studio.delete()
+    Console().print("Studio successfully deleted")

lightning_sdk/cli/legacy/deploy/_auth.py

@@ -0,0 +1,196 @@
+import os
+import time
+from datetime import datetime
+from enum import Enum
+from typing import Any, List, Optional, TypedDict
+from urllib.parse import urlencode
+
+from rich.console import Console
+from rich.prompt import Confirm
+
+from lightning_sdk import Teamspace
+from lightning_sdk.api import UserApi
+from lightning_sdk.cli.utils.teamspace_selection import TeamspacesMenu
+from lightning_sdk.lightning_cloud import env
+from lightning_sdk.lightning_cloud.login import Auth, AuthServer
+from lightning_sdk.lightning_cloud.openapi import V1CloudSpace
+from lightning_sdk.lightning_cloud.rest_client import LightningClient
+from lightning_sdk.utils.resolve import _get_authed_user, _resolve_teamspace
+
+LITSERVE_CODE = os.environ.get("LITSERVE_CODE", "j39bzk903h")
+_POLL_TIMEOUT = 120
+
+
+class _AuthMode(Enum):
+    DEVBOX = "dev"
+    DEPLOY = "deploy"
+
+
+class _AuthServer(AuthServer):
+    def __init__(self, mode: _AuthMode, *args: Any, **kwargs: Any) -> None:
+        self._mode = mode
+        super().__init__(*args, **kwargs)
+
+    def get_auth_url(self, port: int) -> str:
+        redirect_uri = f"http://localhost:{port}/login-complete"
+        params = urlencode({"redirectTo": redirect_uri, "mode": self._mode.value, "okbhrt": LITSERVE_CODE})
+        return f"{env.LIGHTNING_CLOUD_URL}/sign-in?{params}"
+
+
+class _AuthLitServe(Auth):
+    def __init__(self, mode: _AuthMode, shall_confirm: bool = False) -> None:
+        super().__init__()
+        self._mode = mode
+        self._shall_confirm = shall_confirm
+
+    def _run_server(self) -> None:
+        if self._shall_confirm:
+            proceed = Confirm.ask(
+                "[bold yellow]LitServe needs to authenticate with Lightning AI to deploy your server.[/bold yellow]\n"
+                "This will open a browser window for login.\n"
+                "Do you want to continue?",
+                default=True,
+            )
+            if not proceed:
+                raise RuntimeError(
+                    "Login cancelled. Please login to Lightning AI to deploy the API. Run `lightning login` to login."
+                )
+        print("Opening browser for authentication...")
+        print("Please come back to the terminal after logging in.")
+        time.sleep(3)
+        _AuthServer(self._mode).login_with_browser(self)
+
+
+def authenticate(mode: _AuthMode, shall_confirm: bool = True) -> None:
+    """Authenticate with Lightning AI.
+
+    This will open a browser window for authentication.
+    If `shall_confirm` is True, it will ask for confirmation before proceeding.
+    """
+    auth = _AuthLitServe(mode, shall_confirm)
+    auth.authenticate()
+
+
+def select_teamspace(teamspace: Optional[str], org: Optional[str], user: Optional[str]) -> Teamspace:
+    if teamspace is None:
+        menu = TeamspacesMenu()
+        possible_teamspaces = menu._get_possible_teamspaces(_get_authed_user())
+        if len(possible_teamspaces) == 1:
+            name = next(iter(possible_teamspaces.values()))["name"]
+            return Teamspace(name=name, org=org, user=user)
+
+        return menu(teamspace)
+
+    return _resolve_teamspace(teamspace=teamspace, org=org, user=user)
+
+
+class _UserStatus(TypedDict):
+    verified: bool
+    onboarded: bool
+
+
+def poll_verified_status(timeout: int = _POLL_TIMEOUT) -> _UserStatus:
+    """Polls the verified status of the user until it is True or a timeout occurs."""
+    user_api = UserApi()
+    user = _get_authed_user()
+    start_time = datetime.now()
+    result = _UserStatus(onboarded=False, verified=False)
+    while True:
+        user_resp = user_api.get_user(name=user.name)
+        result["onboarded"] = user_resp.status.completed_project_onboarding
+        result["verified"] = user_resp.status.verified
+        if user_resp.status.verified:
+            return result
+        if (datetime.now() - start_time).total_seconds() > timeout:
+            break
+        time.sleep(5)
+    return result
+
+
+class _OnboardingStatus(Enum):
+    NOT_VERIFIED = "not_verified"
+    ONBOARDING = "onboarding"
+    ONBOARDED = "onboarded"
+
+
+class _Onboarding:
+    def __init__(self, console: Console) -> None:
+        self.console = console
+        self.user = _get_authed_user()
+        self.user_api = UserApi()
+        self.client = LightningClient(max_tries=7)
+
+    @property
+    def verified(self) -> bool:
+        return self.user_api.get_user(name=self.user.name).status.verified
+
+    @property
+    def is_onboarded(self) -> bool:
+        return self.user_api.get_user(name=self.user.name).status.completed_project_onboarding
+
+    @property
+    def can_join_org(self) -> bool:
+        return len(self.client.organizations_service_list_joinable_organizations().joinable_organizations) > 0
+
+    @property
+    def status(self) -> _OnboardingStatus:
+        if not self.verified:
+            return _OnboardingStatus.NOT_VERIFIED
+        if self.is_onboarded:
+            return _OnboardingStatus.ONBOARDED
+        return _OnboardingStatus.ONBOARDING
+
+    def _wait_user_onboarding(self, timeout: int = _POLL_TIMEOUT) -> None:
+        """Wait for user onboarding if they can join the teamspace otherwise move to select a teamspace."""
+        status = self.status
+        if status == _OnboardingStatus.ONBOARDED:
+            return
+
+        self.console.print("Waiting for account setup. Visit lightning.ai")
+        start_time = datetime.now()
+        while self.status != _OnboardingStatus.ONBOARDED:
+            time.sleep(5)
+            if self.is_onboarded:
+                return
+            if (datetime.now() - start_time).total_seconds() > timeout:
+                break
+
+        raise RuntimeError("Timed out waiting for onboarding status")
+
+    def get_cloudspace_id(self, teamspace: Teamspace) -> Optional[str]:
+        cloudspaces: List[V1CloudSpace] = self.client.cloud_space_service_list_cloud_spaces(teamspace.id).cloudspaces
+        cloudspaces = sorted(cloudspaces, key=lambda cloudspace: cloudspace.created_at, reverse=True)
+        if len(cloudspaces) == 0:
+            raise RuntimeError("Error creating deployment! Finish account setup at lightning.ai first.")
+        # get the first cloudspace
+        cloudspace = cloudspaces[0]
+        if "scratch-studio" in cloudspace.name or "scratch-studio" in cloudspace.display_name:
+            return cloudspace.id
+        return None
+
+    def select_teamspace(self, teamspace: Optional[str], org: Optional[str], user: Optional[str]) -> Teamspace:
+        """Select a teamspace while onboarding.
+
+        If user is being onboarded and can't join any org, the teamspace it will be resolved to the default
+         personal teamspace.
+        If user is being onboarded and can join an org then it will select default teamspace from the org.
+        """
+        if self.is_onboarded:
+            return select_teamspace(teamspace, org, user)
+
+        # Run only when user hasn't completed onboarding yet.
+        menu = TeamspacesMenu()
+        self._wait_user_onboarding()
+        # Onboarding has been completed - user already selected organization if they could
+        possible_teamspaces = menu._get_possible_teamspaces(self.user)
+        if len(possible_teamspaces) == 1:
+            # User didn't select any org
+            value = next(iter(possible_teamspaces.values()))
+            return Teamspace(name=value["name"], org=value["org"], user=value["user"])
+
+        for _, value in possible_teamspaces.items():
+            # User select an org
+            # Onboarding teamspace will be the default teamspace in the selected org
+            if value["org"]:
+                return Teamspace(name=value["name"], org=value["org"], user=value["user"])
+        raise RuntimeError("Unable to select teamspace. Visit lightning.ai")

lightning_sdk/cli/legacy/deploy/devbox.py

@@ -0,0 +1,163 @@
+import concurrent.futures
+import os
+import re
+import webbrowser
+from pathlib import Path
+from threading import Thread
+from typing import Dict, Optional
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.prompt import Confirm
+from rich.syntax import Syntax
+
+from lightning_sdk import Machine
+from lightning_sdk.cli.legacy.deploy._auth import (
+    _AuthMode,
+    _Onboarding,
+    authenticate,
+    poll_verified_status,
+    select_teamspace,
+)
+from lightning_sdk.cli.legacy.upload import (
+    _dump_current_upload_state,
+    _resolve_previous_upload_state,
+    _single_file_upload,
+)
+from lightning_sdk.lightning_cloud.openapi import V1CloudSpaceSourceType
+from lightning_sdk.studio import Studio
+from lightning_sdk.utils.resolve import _get_studio_url
+
+
+# TODO: Move the rest of the devbox logic here
+class _LitServeDevbox:
+    """Build LitServe API in a Studio."""
+
+    def resolve_previous_upload(self, studio: Studio, folder: str) -> Dict[str, str]:
+        remote_path = "."
+        pairs = {}
+        for root, _, files in os.walk(folder):
+            rel_root = os.path.relpath(root, folder)
+            for f in files:
+                pairs[os.path.join(root, f)] = os.path.join(remote_path, rel_root, f)
+        return _resolve_previous_upload_state(studio, remote_path, pairs)
+
+    def upload_folder(self, studio: Studio, folder: str, upload_state: Dict[str, str]) -> None:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+            futures = []
+            for k, v in upload_state.items():
+                futures.append(
+                    executor.submit(_single_file_upload, studio=studio, local_path=k, remote_path=v, progress_bar=False)
+                )
+            total_files = len(upload_state)
+
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                TimeElapsedColumn(),
+                console=Console(),
+                transient=True,
+            ) as progress:
+                upload_task = progress.add_task(f"[cyan]Uploading {total_files} files to Studio...", total=total_files)
+                for f in concurrent.futures.as_completed(futures):
+                    upload_state.pop(f.result())
+                    _dump_current_upload_state(studio, ".", upload_state)
+                    progress.update(upload_task, advance=1)
+
+    def _detect_port(self, script_path: Path) -> int:
+        with open(script_path) as f:
+            content = f.read()
+
+        # Try to match server.run first and then any variable name and then default port=8000
+        match = re.search(r"server\.run\s*\([^)]*port\s*=\s*(\d+)", content) or re.search(
+            r"\w+\.run\s*\([^)]*port\s*=\s*(\d+)", content
+        )
+        return int(match.group(1)) if match else 8000
+
+
+def _handle_devbox(
+    name: str,
+    script_path: Path,
+    console: Console,
+    non_interactive: bool = False,
+    machine: Machine = Machine.CPU,
+    interruptible: bool = False,
+    teamspace: Optional[str] = None,
+    org: Optional[str] = None,
+    user: Optional[str] = None,
+) -> None:
+    if script_path.suffix != ".py":
+        console.print("❌ Error: Only Python files (.py) are supported for development servers", style="red")
+        return
+
+    from_onboarding = False
+    authenticate(_AuthMode.DEVBOX, shall_confirm=not non_interactive)
+    user_status = poll_verified_status()
+    if not user_status["verified"]:
+        console.print("❌ Verify phone number to continue. Visit lightning.ai.", style="red")
+        return
+    if not user_status["onboarded"]:
+        console.print("onboarding user")
+        onboarding = _Onboarding(console)
+        resolved_teamspace = onboarding.select_teamspace(teamspace, org, user)
+        from_onboarding = True
+    else:
+        resolved_teamspace = select_teamspace(teamspace, org, user)
+    studio = Studio(name=name, teamspace=resolved_teamspace, source=V1CloudSpaceSourceType.LITSERVE)
+    studio.install_plugin("custom-port")
+    lit_devbox = _LitServeDevbox()
+
+    studio_url = _get_studio_url(studio, turn_on=True)
+    pathlib_path = Path(script_path).resolve()
+    browser_opened = False
+    studio_path = f"{studio.owner.name}/{studio.teamspace.name}/{studio.name}"
+
+    console.print("\n=== Lightning Studio Setup ===")
+    console.print(f"🔧 [bold]Setting up Studio:[/bold] {studio_path}")
+    console.print(f"📁 [bold]Local project:[/bold] {pathlib_path.parent}")
+
+    upload_state = lit_devbox.resolve_previous_upload(studio, str(pathlib_path.parent))
+    if non_interactive:
+        console.print(f"🌐 [bold]Opening Studio:[/bold] [link={studio_url}]{studio_url}[/link]")
+        browser_opened = webbrowser.open(studio_url)
+    elif not from_onboarding:
+        if Confirm.ask("Would you like to open your Studio in the browser?", default=True):
+            console.print(f"🌐 [bold]Opening Studio:[/bold] [link={studio_url}]{studio_url}[/link]")
+            browser_opened = webbrowser.open(studio_url)
+
+    if not browser_opened:
+        console.print(f"🔗 [bold]Access Studio:[/bold] [link={studio_url}]{studio_url}[/link]")
+
+    # Start the Studio in the background and return immediately using threading
+    console.print("\n⚡ Initializing Studio in the background...")
+    studio_thread = Thread(target=studio.start, args=(machine, interruptible))
+    studio_thread.start()
+
+    console.print("📤 Syncing project files to Studio...")
+    lit_devbox.upload_folder(studio, pathlib_path.parent, upload_state)
+
+    # Wait for the Studio to start
+    console.print("⚡ Waiting for Studio to start...")
+    studio_thread.join()
+
+    try:
+        console.print("🚀 Starting server...")
+        studio.run_and_detach(f"python {script_path}", timeout=10)
+    except Exception as e:
+        console.print("❌ Error while starting server", style="red")
+        syntax = Syntax(f"{e}", "bash", theme="monokai")
+        console.print(syntax)
+        console.print(f"\n🔄 [bold]To fix:[/bold] Edit your code in Studio and run with: [u]python {script_path}[/u]")
+        return
+
+    port = lit_devbox._detect_port(pathlib_path)
+    console.print("🔌 Configuring server port...")
+    port_url = studio.run_plugin("custom-port", port=port)
+
+    # Add completion message with next steps
+    console.print("\n✅ Studio ready!")
+    console.print("\n📋 [bold]Next steps:[/bold]")
+    console.print("  [bold]1.[/bold] Server code will be available in the Studio")
+    console.print("  [bold]2.[/bold] The Studio is now running with the specified configuration")
+    console.print("  [bold]3.[/bold] Modify and run your server directly in the Studio")
+    console.print(f"  [bold]4.[/bold] Your server will be accessible on [link={port_url}]{port_url}[/link]")