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

lightning_sdk/cli/utils/coloring.py

@@ -0,0 +1,60 @@
+from typing import Optional, Sequence, Tuple
+
+from click.formatting import HelpFormatter, term_len, wrap_text
+from click.termui import style
+
+
+class CustomHelpFormatter(HelpFormatter):
+    _primary = "magenta"
+    _secondary = "cyan"
+
+    def write_heading(self, heading: str) -> None:
+        # Style the heading (command name) in cyan
+        return super().write_heading(style(heading, fg=self._primary, bold=True))
+
+    def write_usage(self, prog: str, args: str = "", prefix: Optional[str] = None) -> None:
+        if prefix is None:
+            prefix = "Usage: "
+
+        styled_prefix = style(prefix, fg=self._primary, bold=True)
+        styled_prog = style(prog, fg=self._secondary, bold=True)
+        styled_args = style(args, fg=self._secondary, bold=True)
+
+        # this is required because otherwise the super() call would include the special characters for coloring in the
+        # width and indent computation leading to wrong results since these characters won't be displayed in the end.
+        usage_prefix = f"{prefix:>{self.current_indent}}{prog} "
+        styled_usage_prefix = f"{styled_prefix:>{self.current_indent}}{styled_prog} "
+        text_width = self.width - self.current_indent
+
+        if text_width >= (term_len(usage_prefix) + 20):
+            # The arguments will fit to the right of the prefix.
+            self.write(styled_usage_prefix)
+            indent = " " * term_len(usage_prefix)
+            self.write(
+                wrap_text(
+                    styled_args,
+                    text_width,
+                    initial_indent="",
+                    subsequent_indent=indent,
+                )
+            )
+        else:
+            # The prefix is too long, put the arguments on the next line.
+            self.write(styled_usage_prefix)
+            self.write("\n")
+            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
+            self.write(wrap_text(styled_args, text_width, initial_indent=indent, subsequent_indent=indent))
+
+        self.write("\n")
+
+    def write_dl(
+        self,
+        rows: Sequence[Tuple[str, str]],
+        col_max: int = 30,
+        col_spacing: int = 2,
+    ) -> None:
+        new_rows = []
+        for row in rows:
+            new_row = (style(row[0], fg=self._secondary, bold=True), row[1])
+            new_rows.append(new_row)
+        super().write_dl(new_rows, col_max=col_max, col_spacing=col_spacing)

lightning_sdk/cli/utils/get_base_studio.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from lightning_sdk.base_studio import BaseStudio
+
+
+def get_base_studio_id(studio_type: Optional[str]) -> Optional[str]:
+    base_studios = BaseStudio()
+    base_studios = base_studios.list()
+    template_id = None
+
+    if base_studios and len(base_studios):
+        # if not specified by user, use the first existing template studio
+        template_id = base_studios[0].id
+        # else, try to match the provided studio_type to base studio name
+        if studio_type:
+            normalized_studio_type = studio_type.lower().replace(" ", "-")
+            match = next(
+                (s for s in base_studios if s.name.lower().replace(" ", "-") == normalized_studio_type),
+                None,
+            )
+            if match:
+                template_id = match.id
+
+    return template_id

lightning_sdk/cli/utils/handle_machine_and_gpus_args.py

@@ -0,0 +1,69 @@
+from typing import Dict, Optional, Set
+
+import click
+
+from lightning_sdk.machine import DEFAULT_MACHINE, Machine
+
+
+def _split_gpus_spec(gpus: str) -> tuple[str, int]:
+    machine_name, machine_val = gpus.split(":", 1)
+    machine_name = machine_name.strip()
+    machine_val = machine_val.strip()
+
+    if not machine_val.isdigit() or int(machine_val) <= 0:
+        raise ValueError(f"Invalid GPU count '{machine_val}'. Must be a positive integer.")
+
+    machine_num = int(machine_val)
+    return machine_name, machine_num
+
+
+def _construct_available_gpus(machine_options: Dict[str, str]) -> Set[str]:
+    # returns available gpus:count
+    available_gpus = set()
+    for v in machine_options.values():
+        if "_X_" in v:
+            gpu_type_num = v.replace("_X_", ":")
+            available_gpus.add(gpu_type_num)
+        else:
+            available_gpus.add(v)
+    return available_gpus
+
+
+def _get_machine_from_gpus(gpus: str) -> Machine:
+    machine_name = gpus
+    machine_num = 1
+
+    if ":" in gpus:
+        machine_name, machine_num = _split_gpus_spec(gpus)
+
+    machine_options = {
+        m.name.lower(): m.name for m in Machine.__dict__.values() if isinstance(m, Machine) and m._include_in_cli
+    }
+
+    if machine_num == 1:
+        # e.g. gpus=L4 or gpus=L4:1
+        gpu_key = machine_name.lower()
+        try:
+            return machine_options[gpu_key]
+        except KeyError:
+            available = ", ".join(_construct_available_gpus(machine_options))
+            raise ValueError(f"Invalid GPU type '{machine_name}'. Available options: {available}") from None
+
+    # Else: e.g. gpus=L4:4
+    gpu_key = f"{machine_name.lower()}_x_{machine_num}"
+    try:
+        return machine_options[gpu_key]
+    except KeyError:
+        available = ", ".join(_construct_available_gpus(machine_options))
+        raise ValueError(f"Invalid GPU configuration '{gpus}'. Available options: {available}") from None
+
+
+def handle_machine_and_gpus_args(machine: Optional[str], gpus: Optional[str]) -> str:
+    if machine and gpus:
+        raise click.UsageError("Options --machine and --gpus are mutually exclusive. Provide only one.")
+    elif gpus:
+        machine = _get_machine_from_gpus(gpus.strip())
+    elif not machine:
+        machine = DEFAULT_MACHINE
+
+    return machine

lightning_sdk/cli/utils/logging.py

@@ -0,0 +1,122 @@
+import shlex
+import sys
+import traceback
+from contextlib import suppress
+from time import time
+from types import TracebackType
+from typing import Optional, Type
+
+import click
+from rich.console import Group
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+from lightning_sdk.__version__ import __version__
+from lightning_sdk.cli.utils import rich_to_str
+from lightning_sdk.constants import _LIGHTNING_DEBUG
+from lightning_sdk.lightning_cloud.openapi.models.v1_create_sdk_command_history_request import (
+    V1CreateSDKCommandHistoryRequest,
+)
+from lightning_sdk.lightning_cloud.openapi.models.v1_sdk_command_history_severity import V1SDKCommandHistorySeverity
+from lightning_sdk.lightning_cloud.openapi.models.v1_sdk_command_history_type import V1SDKCommandHistoryType
+from lightning_sdk.lightning_cloud.rest_client import LightningClient
+
+
+def _log_command(message: str = "", duration: int = 0, error: Optional[str] = None) -> None:
+    original_command = " ".join(shlex.quote(arg) for arg in sys.argv)
+    client = LightningClient(retry=False, max_tries=0)
+
+    body = V1CreateSDKCommandHistoryRequest(
+        command=original_command,
+        duration=duration,
+        message=f"VERSION: {__version__} | {message}",
+        project_id=None,
+        severity=V1SDKCommandHistorySeverity.INFO,
+        type=V1SDKCommandHistoryType.CLI,
+    )
+
+    if error:
+        body.severity = V1SDKCommandHistorySeverity.WARNING if error == "0" else V1SDKCommandHistorySeverity.ERROR
+        body.message = body.message + f" | Error: {error}"
+
+    # limit characters
+    body.message = body.message[:1000]
+
+    with suppress(Exception):
+        client.s_dk_command_history_service_create_sdk_command_history(body=body)
+
+
+def _notify_exception(exception_type: Type[BaseException], value: BaseException, tb: TracebackType) -> None:
+    """CLI won't show tracebacks, just print the exception message."""
+    message = str(value.args[0]) if value.args else str(value) or "An unknown error occurred"
+
+    error_text = Text()
+    error_text.append(f"{exception_type.__name__}: ", style="bold red")
+    error_text.append(message, style="white")
+
+    renderables = [error_text]
+
+    if _LIGHTNING_DEBUG:
+        tb_text = "".join(traceback.format_exception(exception_type, value, tb))
+        renderables.append(Text("\n\nFull traceback:\n", style="bold yellow"))
+        renderables.append(Syntax(tb_text, "python", theme="monokai light", line_numbers=False, word_wrap=True))
+    else:
+        renderables.append(Text("\n\n🐞 To view the full traceback, set: LIGHTNING_DEBUG=1"))
+
+    renderables.append(Text("\n📘 Need help? Run: lightning <command> --help", style="cyan"))
+
+    text = rich_to_str(Panel(Group(*renderables), title="⚡ Lightning CLI Error", border_style="red"))
+    click.echo(text, color=True)
+
+
+def logging_excepthook(exception_type: Type[BaseException], value: BaseException, tb: TracebackType) -> None:
+    try:
+        tb_str = "".join(traceback.format_exception(exception_type, value, tb))
+        ctx = click.get_current_context(silent=True)
+        command_context = ctx.command_path if ctx else "outside_command_context"
+
+        message = (
+            f"Command: {command_context} | Type: {exception_type.__name__!s} | Value: {value!s} | Traceback: {tb_str}"
+        )
+        _log_command(message=message)
+    finally:
+        _notify_exception(exception_type, value, tb)
+
+
+class CommandLoggingGroup(click.Group):
+    def _format_ctx(self, ctx: click.Context) -> str:
+        parts = []
+        for k, v in ctx.params.items():
+            if v is True:
+                parts.append(f"--{k}")
+            elif v is False or v is None:
+                continue
+            else:
+                parts.append(f"--{k} {v}")
+        params = " ".join(parts)
+        args = " ".join(ctx.args)
+        return (
+            f"""Commands: {ctx.command_path} | Subcommand: {ctx.invoked_subcommand} | Params: {params} | Args:{args}"""
+        )
+
+    def invoke(self, ctx: click.Context) -> any:
+        """Overrides the default invoke to wrap command execution with tracking."""
+        start_time = time()
+        error_message = None
+
+        try:
+            return super().invoke(ctx)
+        except click.ClickException as e:
+            error_message = str(e)
+            e.show()
+            ctx.exit(e.exit_code)
+        except Exception as e:
+            error_message = str(e)
+            raise
+        finally:
+            _log_command(
+                message=self._format_ctx(ctx),
+                duration=int(time() - start_time),
+                error=error_message,
+            )

lightning_sdk/cli/utils/owner_selection.py

@@ -0,0 +1,110 @@
+import os
+from contextlib import suppress
+from typing import Dict, List, Optional, TypedDict
+
+import click
+from simple_term_menu import TerminalMenu
+
+from lightning_sdk.cli.legacy.exceptions import StudioCliError
+from lightning_sdk.organization import Organization
+from lightning_sdk.owner import Owner
+from lightning_sdk.user import User
+from lightning_sdk.utils.resolve import ApiException, _get_authed_user, _resolve_org, _resolve_user
+
+
+class _OwnerMenuType(TypedDict):
+    name: str
+    is_org: bool
+
+
+class OwnerMenu:
+    """This class is used to select a teamspace owner (org/user) from a list of possible owners.
+
+    It can be used to select an owner from a list of possible owners, or to resolve an owner from a name.
+    """
+
+    def _get_owner_from_interactive_menu(self, possible_owners: Dict[str, _OwnerMenuType]) -> _OwnerMenuType:
+        owner_ids = sorted(possible_owners.keys())
+        terminal_menu = self._prepare_terminal_menu_owners([possible_owners[k] for k in owner_ids])
+        terminal_menu.show()
+
+        selected_id = owner_ids[terminal_menu.chosen_menu_index]
+        return possible_owners[selected_id]
+
+    def _get_owner_from_name(self, owner: str, possible_owners: Dict[str, _OwnerMenuType]) -> _OwnerMenuType:
+        for _, ts in possible_owners.items():
+            if ts["name"]:
+                return ts
+
+        click.echo(f"Could not find Owner {owner}, please select it from the list:")
+        return self._get_owner_from_interactive_menu(possible_owners)
+
+    @staticmethod
+    def _prepare_terminal_menu_owners(
+        possible_owners: List[_OwnerMenuType], title: Optional[str] = None
+    ) -> TerminalMenu:
+        if title is None:
+            title = "Please select a Teamspace-Owner out of the following:"
+
+        return TerminalMenu(
+            [f"{to['name']} ({'Organization' if to['is_org'] else 'User'})" for to in possible_owners],
+            title=title,
+            clear_menu_on_exit=True,
+        )
+
+    @staticmethod
+    def _get_possible_owners(user: User) -> Dict[str, _OwnerMenuType]:
+        user_api = user._user_api
+
+        orgs = user_api._get_organizations_for_authed_user()
+        owners: Dict[str, _OwnerMenuType] = {user.id: {"name": user.name, "is_org": False}}
+
+        for org in orgs:
+            owners[org.id] = {"name": org.name, "is_org": True}
+
+        return owners
+
+    def __call__(self, owner: Optional[str] = None) -> Owner:
+        try:
+            # try to resolve the teamspace from the name, environment or config
+            resolved_owner = None
+            with suppress(ApiException, ValueError, RuntimeError):
+                resolved_owner = _resolve_org(owner)
+
+            if resolved_owner is not None:
+                return resolved_owner
+
+            with suppress(ApiException, ValueError, RuntimeError):
+                resolved_owner = _resolve_user(owner)
+
+            if resolved_owner is not None:
+                return resolved_owner
+
+            if os.environ.get("LIGHTNING_NON_INTERACTIVE", "0") == "1":
+                raise ValueError(
+                    "Owner selection is not supported in non-interactive mode. Please provide an owner name."
+                )
+
+            # if the owner is not resolved, try to get the owner from the interactive menu
+            # this could mean that either no owner was provided or the provided owner is not valid
+            user = _get_authed_user()
+
+            possible_owners = self._get_possible_owners(user)
+            if owner is None:
+                owner_dict = self._get_owner_from_interactive_menu(possible_owners=possible_owners)
+
+            else:
+                owner_dict = self._get_owner_from_name(owner=owner, possible_owners=possible_owners)
+
+            if owner_dict.get("is_org", False):
+                return Organization(owner_dict.get("name", None))
+
+            return User(owner_dict.get("name", None))
+        except KeyboardInterrupt:
+            raise KeyboardInterrupt from None
+
+        except Exception as e:
+            raise StudioCliError(
+                f"Could not find the given Teamspace-Owner {owner}. "
+                "Please contact Lightning AI directly to resolve this issue."
+            ) from e

lightning_sdk/cli/utils/resolve.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from lightning_sdk.teamspace import Teamspace
+from lightning_sdk.utils.resolve import _resolve_teamspace
+
+
+def resolve_teamspace_owner_name_format(teamspace_name: Optional[str]) -> Optional[Teamspace]:
+    teamspace_resolved = None
+    if teamspace_name is None:
+        return _resolve_teamspace(None, None, None)
+
+    splits = teamspace_name.split("/")
+    if len(splits) == 1:
+        try:
+            teamspace_resolved = _resolve_teamspace(teamspace_name, None, None)
+        except Exception:
+            teamspace_resolved = None
+
+    elif len(splits) == 2:
+        try:
+            try:
+                teamspace_resolved = _resolve_teamspace(splits[1], splits[0], None)
+            except Exception:
+                teamspace_resolved = _resolve_teamspace(splits[1], None, splits[0])
+        except Exception:
+            teamspace_resolved = None
+
+    return teamspace_resolved

lightning_sdk/cli/utils/richt_print.py

@@ -0,0 +1,35 @@
+import os
+from typing import Any
+
+from rich.console import Console
+
+from lightning_sdk.studio import Studio
+from lightning_sdk.utils.resolve import _get_studio_url
+
+
+def rich_to_str(*renderables: Any) -> str:
+    with open(os.devnull, "w") as f:
+        console = Console(file=f, record=True)
+        console.print(*renderables)
+    return console.export_text(styles=True)
+
+
+# not supported on all terminals (e.g. older ones). in that case it's a name without a link
+# see https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda#hyperlinks-aka-html-like-anchors-in-terminal-emulators
+# for details and
+# https://github.com/Alhadis/OSC8-Adoption/blob/main/README.md for status of OSC8 adoption
+def studio_name_link(studio: Studio, to_ascii: bool = True) -> str:
+    """Hyperlink a studio name.
+
+    Args:
+      studio: the studio whose name to print and link to the studio url
+      to_ascii: whether return a plain ascii string with characters for linking converted to ascii as well.
+        if False, returns the rich markup directly.
+    """
+    url = _get_studio_url(studio)
+
+    studio_link_markup = f"[link={url}]{studio.name}[/link]"
+    if not to_ascii:
+        return studio_link_markup
+
+    return rich_to_str(studio_link_markup).strip("\n")

lightning_sdk/cli/utils/save_to_config.py

@@ -0,0 +1,27 @@
+from lightning_sdk.organization import Organization
+from lightning_sdk.studio import Studio
+from lightning_sdk.teamspace import Teamspace
+from lightning_sdk.utils.config import Config, DefaultConfigKeys
+
+
+def save_teamspace_to_config(teamspace: Teamspace, overwrite: bool = False) -> None:
+    saved = _save_to_config_if_not_exists(DefaultConfigKeys.teamspace_name, teamspace.name, overwrite)
+    saved = _save_to_config_if_not_exists(DefaultConfigKeys.teamspace_owner, teamspace.owner.name, overwrite=saved)
+    saved = _save_to_config_if_not_exists(
+        DefaultConfigKeys.teamspace_owner_type,
+        "organization" if isinstance(teamspace.owner, Organization) else "user",
+        overwrite=saved,
+    )
+
+
+def save_studio_to_config(studio: Studio, overwrite: bool = False) -> None:
+    saved = _save_to_config_if_not_exists(DefaultConfigKeys.studio, studio.name, overwrite)
+    save_teamspace_to_config(studio.teamspace, overwrite=saved)
+
+
+def _save_to_config_if_not_exists(key: str, value: str, overwrite: bool = False) -> bool:
+    cfg = Config()
+    if overwrite or cfg.get(key) is None:
+        cfg.set(key, value)
+        return True
+    return False

lightning_sdk/cli/utils/ssh_connection.py

@@ -0,0 +1,59 @@
+import os
+import platform
+import uuid
+from pathlib import Path
+from typing import Optional
+
+from lightning_sdk.lightning_cloud.login import Auth
+from lightning_sdk.utils.config import _DEFAULT_CONFIG_FILE_PATH
+
+
+def configure_ssh_internal(force_download: bool = False) -> str:
+    """Internal function to configure SSH without Click decorators."""
+    auth = Auth()
+    auth.authenticate()
+    return download_ssh_keys(auth.api_key, force_download=force_download)
+
+
+def download_ssh_keys(
+    api_key: Optional[str],
+    force_download: bool = False,
+    ssh_key_name: str = "lightning_rsa",
+) -> str:
+    """Download the SSH key for a User."""
+    ssh_private_key_path = os.path.join(os.path.expanduser(os.path.dirname(_DEFAULT_CONFIG_FILE_PATH)), ssh_key_name)
+
+    os.makedirs(os.path.dirname(ssh_private_key_path), exist_ok=True)
+
+    if not os.path.isfile(ssh_private_key_path) or force_download:
+        key_id = str(uuid.uuid4())
+        download_file(
+            f"https://lightning.ai/setup/ssh-gen?t={api_key}&id={key_id}&machineName={platform.node()}",
+            Path(ssh_private_key_path),
+            overwrite=True,
+            chmod=0o600,
+        )
+        download_file(
+            f"https://lightning.ai/setup/ssh-public?t={api_key}&id={key_id}",
+            Path(ssh_private_key_path + ".pub"),
+            overwrite=True,
+        )
+
+    return ssh_private_key_path
+
+
+def download_file(url: str, local_path: Path, overwrite: bool = True, chmod: Optional[int] = None) -> None:
+    """Download a file from a URL."""
+    import requests
+
+    if os.path.isfile(local_path) and not overwrite:
+        raise FileExistsError(f"The file {local_path} already exists and overwrite is set to False.")
+
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+
+    with open(local_path, "wb") as file:
+        for chunk in response.iter_content(chunk_size=8192):
+            file.write(chunk)
+    if chmod is not None:
+        os.chmod(local_path, 0o600)

lightning_sdk/cli/utils/studio_selection.py

@@ -0,0 +1,113 @@
+import os
+from contextlib import suppress
+from typing import Dict, List, Optional, Union
+
+import click
+from simple_term_menu import TerminalMenu
+
+from lightning_sdk.cli.legacy.exceptions import StudioCliError
+from lightning_sdk.studio import VM, Studio
+from lightning_sdk.teamspace import Teamspace
+from lightning_sdk.utils.resolve import _get_authed_user
+
+
+class StudiosMenu:
+    """This class is used to select a studio from a list of possible studios within a teamspace.
+
+    It can be used to select a studio from a list of possible studios, or to resolve a studio from a name.
+    """
+
+    def __init__(self, teamspace: Teamspace, vm: bool = False) -> None:
+        """Initialize the StudiosMenu with a teamspace.
+
+        Args:
+            teamspace: The teamspace to list studios from
+        """
+        self.teamspace = teamspace
+        self.vm = vm
+
+    def _get_studio_from_interactive_menu(self, possible_studios: Dict[str, Union[Studio, VM]]) -> Union[Studio, VM]:
+        studio_names = sorted(possible_studios.keys())
+        terminal_menu = self._prepare_terminal_menu_studios(studio_names, vm=self.vm)
+        terminal_menu.show()
+
+        selected_name = studio_names[terminal_menu.chosen_menu_index]
+        return possible_studios[selected_name]
+
+    def _get_studio_from_name(self, studio: str, possible_studios: Dict[str, Union[Studio, VM]]) -> Union[Studio, VM]:
+        if studio in possible_studios:
+            return possible_studios[studio]
+
+        click.echo(f"Could not find {'VM' if self.vm else 'Studio'} {studio}, please select it from the list:")
+        return self._get_studio_from_interactive_menu(possible_studios)
+
+    @staticmethod
+    def _prepare_terminal_menu_studios(
+        studio_names: List[str], title: Optional[str] = None, vm: bool = False
+    ) -> TerminalMenu:
+        if title is None:
+            title = f"Please select a {'VM' if vm else 'Studio'} out of the following:"
+
+        return TerminalMenu(studio_names, title=title, clear_menu_on_exit=True)
+
+    def _get_possible_studios(self) -> Dict[str, Union[Studio, VM]]:
+        """Get all available studios in the teamspace."""
+        studios: Dict[str, Union[Studio, VM]] = {}
+
+        user = _get_authed_user()
+        teamspace_studios = self.teamspace.vms if self.vm else self.teamspace.studios
+        for studio in teamspace_studios:
+            if studio._studio.user_id == user.id:
+                studios[studio.name] = studio
+        return studios
+
+    def __call__(self, studio: Optional[str] = None) -> Union[Studio, VM]:
+        """Select a studio from the teamspace.
+
+        Args:
+            studio: Optional studio name to select. If not provided, will show interactive menu.
+
+        Returns:
+            Selected Studio/VM object
+
+        Raises:
+            StudioCliError: If studio selection fails
+        """
+        try:
+            # try to resolve the studio from the name, environment or config
+            resolved_studio = None
+
+            selected_cls = VM if self.vm else Studio
+
+            with suppress(Exception):
+                resolved_studio = selected_cls(name=studio, teamspace=self.teamspace, create_ok=False)
+
+            if resolved_studio is not None:
+                return resolved_studio
+
+            if os.environ.get("LIGHTNING_NON_INTERACTIVE", "0") == "1" and studio is None:
+                raise ValueError(
+                    f"{'VM' if self.vm else 'Studio'} selection is not supported in non-interactive mode. "
+                    "Please provide a studio name."
+                )
+
+            click.echo(f"Listing studios in teamspace {self.teamspace.owner.name}/{self.teamspace.name}...")
+
+            possible_studios = self._get_possible_studios()
+
+            if not possible_studios:
+                raise ValueError(f"No studios found in teamspace {self.teamspace.name}")
+
+            if studio is None:
+                return self._get_studio_from_interactive_menu(possible_studios)
+
+            return self._get_studio_from_name(studio, possible_studios)
+
+        except KeyboardInterrupt:
+            raise KeyboardInterrupt from None
+
+        except Exception as e:
+            raise StudioCliError(
+                f"Could not resolve a {'VM' if self.vm else 'Studio'}. "
+                "Please pass it as an argument or contact Lightning AI directly to resolve this issue."
+            ) from e