lightning-sdk 0.2.21rc1__py3-none-any.whl → 0.2.23__py3-none-any.whl

lightning_sdk/pipeline/printer.py

@@ -0,0 +1,121 @@
+import os
+from typing import Any, ClassVar, Dict, List
+
+from lightning_sdk.lightning_cloud.openapi.models import V1JobSpec, V1Pipeline, V1PipelineStepType
+
+
+class PipelinePrinter:
+    """A helper class to print a formatted summary of a pipeline."""
+
+    STEP_TYPE_MAP: ClassVar[Dict[str, str]] = {
+        V1PipelineStepType.DEPLOYMENT: "Deployment",
+        V1PipelineStepType.JOB: "Job",
+        V1PipelineStepType.MMT: "MMT",
+    }
+
+    def __init__(
+        self,
+        name: str,
+        initial: bool,
+        pipeline: V1Pipeline,
+        teamspace: Any,
+        proto_steps: List[Any],
+        schedules: List[Any],
+    ) -> None:
+        self._name = name
+        self._initial = initial
+        self._pipeline = pipeline
+        self._teamspace = teamspace
+        self._proto_steps = proto_steps
+        self._shared_filesystem = pipeline.shared_filesystem
+        self._schedules = schedules
+        cluster_ids: set[str] = set()
+        for step in self._proto_steps:
+            job_spec = self._get_spec(step)
+            cluster_ids.add(job_spec.cluster_id)
+        self._cluster_ids = cluster_ids
+
+    def print_summary(self) -> None:
+        """Prints the full, formatted summary of the created pipeline."""
+        self._print("\n" + "─" * 60)
+        self._print(f"✅ Pipeline '{self._name}' {'created' if self._initial else 'updated'} successfully!")
+        self._print("─" * 60)
+
+        self._print_steps()
+        self._print_schedules()
+        self._print_cloud_account()
+        self._print_shared_filesystem()
+        self._print_footer()
+
+    def _print(self, value: str) -> None:
+        print(value)
+
+    def _print_steps(self) -> None:
+        """Prints the formatted list of pipeline steps."""
+        self._print("\nWorkflow Steps:")
+        if not self._proto_steps:
+            self._print("  - No steps defined.")
+            return
+
+        for i, step in enumerate(self._proto_steps):
+            step_type = self.STEP_TYPE_MAP.get(step.type, "Unknown Step")
+
+            # Format the 'wait_for' list for cleaner output
+            if not step.wait_for:
+                wait_for_str = "(runs first)"
+            else:
+                # e.g., "'step_a', 'step_b'"
+                wait_for_str = f" waits for {', '.join([f'{w}' for w in step.wait_for])}"
+
+            self._print(f"  ➡️ {i+1}. {step_type} '{step.name}' - {wait_for_str}")
+
+    def _print_schedules(self) -> None:
+        """Prints the formatted list of schedules."""
+        self._print("\n🗓️ Schedules:")
+        if not self._schedules:
+            self._print("  - No schedules defined.")
+            return
+
+        for schedule in self._schedules:
+            self._print(f"  - '{schedule.name}' runs on cron schedule: `{schedule.cron_expression}`")
+
+    def _print_footer(self) -> None:
+        """Prints the final link and closing message."""
+        cloud_url = os.getenv("LIGHTNING_CLOUD_URL", "https://lightning.ai").replace(":443", "")
+
+        # Using properties of assumed objects for a cleaner look
+        owner: str = self._teamspace.owner.name
+        team: str = self._teamspace.name
+        pipeline_name: str = self._name
+
+        pipeline_url = f"{cloud_url}/{owner}/{team}/pipelines/{pipeline_name}?app_id=pipeline"
+
+        self._print("\n" + "─" * 60)
+        self._print(f"🔗 View your pipeline in the browser:\n   {pipeline_url}")
+        self._print("─" * 60 + "\n")
+
+    def _print_cloud_account(self) -> None:
+        if not self._proto_steps:
+            return
+
+        self._print(f"\nCloud account{'s' if len(self._cluster_ids) > 1 else ''}:")
+        for cluster_id in sorted(self._cluster_ids):
+            self._print(f"  - {cluster_id}")
+
+    def _print_shared_filesystem(self) -> None:
+        self._print(f"\nShared filesystem: {self._shared_filesystem.enabled}")
+
+        if self._shared_filesystem.enabled and len(self._cluster_ids) == 1:
+            shared_path = ""
+            if self._pipeline.shared_filesystem.s3_folder:
+                cluster_id = list(self._cluster_ids)[0]  # noqa: RUF015
+                shared_path = f"/teamspace/s3_folders/pipelines-{cluster_id}"
+            if shared_path:
+                self._print(f"  - {shared_path}")
+
+    def _get_spec(self, step: Any) -> V1JobSpec:
+        if step.type == V1PipelineStepType.DEPLOYMENT:
+            return step.deployment.spec
+        if step.type == V1PipelineStepType.MMT:
+            return step.mmt.spec
+        return step.job.spec

lightning_sdk/pipeline/schedule.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Schedule:
+    cron_expression: str
+    name: Optional[str] = None

lightning_sdk/pipeline/{types.py → steps.py}

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from lightning_sdk.api.deployment_api import (
     AutoScaleConfig,
@@ -20,52 +20,61 @@ from lightning_sdk.lightning_cloud.openapi.models import (
     V1CreateDeploymentRequest,
     V1PipelineStep,
     V1PipelineStepType,
+    V1SharedFilesystem,
 )
+from lightning_sdk.machine import Machine
 from lightning_sdk.mmt.v2 import MMTApiV2
+from lightning_sdk.pipeline.utils import DEFAULT, _get_studio, _to_wait_for, _validate_cloud_account
 from lightning_sdk.studio import Studio
 
 if TYPE_CHECKING:
-    from lightning_sdk.machine import Machine
     from lightning_sdk.organization import Organization
     from lightning_sdk.teamspace import Teamspace
     from lightning_sdk.user import User
 
 
-from lightning_sdk.pipeline.utils import DEFAULT
-
-
-class Deployment:
+class DeploymentStep:
     # Note: This class is only temporary while pipeline is wip
 
     def __init__(
         self,
         name: Optional[str] = None,
+        studio: Optional[Union[str, Studio]] = None,
         machine: Optional["Machine"] = None,
         image: Optional[str] = None,
-        autoscale: Optional["AutoScaleConfig"] = None,
-        ports: Optional[List[float]] = None,
-        release_strategy: Optional["ReleaseStrategy"] = None,
+        autoscale: Optional[AutoScaleConfig] = None,
+        ports: Optional[Union[float, List[float]]] = None,
+        release_strategy: Optional[ReleaseStrategy] = None,
         entrypoint: Optional[str] = None,
         command: Optional[str] = None,
-        env: Union[List[Union["Secret", "Env"]], Dict[str, str], None] = None,
+        commands: Optional[List[str]] = None,
+        env: Union[List[Union[Secret, Env]], Dict[str, str], None] = None,
         spot: Optional[bool] = None,
         replicas: Optional[int] = None,
-        health_check: Optional[Union["HttpHealthCheck", "ExecHealthCheck"]] = None,
-        auth: Optional[Union["BasicAuth", "TokenAuth"]] = None,
+        health_check: Optional[Union[HttpHealthCheck, ExecHealthCheck]] = None,
+        auth: Optional[Union[BasicAuth, TokenAuth]] = None,
         cloud_account: Optional[str] = None,
         custom_domain: Optional[str] = None,
         quantity: Optional[int] = None,
-        wait_for: Union[str, List[str]] = DEFAULT,
+        include_credentials: Optional[bool] = None,
+        wait_for: Optional[Union[str, List[str]]] = DEFAULT,
     ) -> None:
         self.name = name
-        self.machine = machine
+        self.studio = _get_studio(studio)
+        if cloud_account and studio and cloud_account != studio.cloud_account != cloud_account:
+            raise ValueError(
+                f"The provided cloud account `{cloud_account}` doesn't match"
+                f" the Studio cloud account {self.studio.cloud_account}"
+            )
+
+        self.machine = machine or Machine.CPU
         self.image = image
         self.autoscale = autoscale or AutoScaleConfig(
             min_replicas=0,
             max_replicas=1,
             target_metrics=[
                 AutoScalingMetric(
-                    name="CPU" if machine.is_cpu() else "GPU",
+                    name="CPU" if self.machine.is_cpu() else "GPU",
                     target=80,
                 )
             ],
@@ -74,22 +83,26 @@ class Deployment:
         self.release_strategy = release_strategy
         self.entrypoint = entrypoint
         self.command = command
+        self.commands = commands
         self.env = env
         self.spot = spot
         self.replicas = replicas or 1
         self.health_check = health_check
         self.auth = auth
-        self.cloud_account = cloud_account or ""
+        self.cloud_account = cloud_account or "" if self.studio is None else self.studio.cloud_account
         self.custom_domain = custom_domain
         self.quantity = quantity
+        self.include_credentials = include_credentials or True
         self.wait_for = wait_for
 
-    def to_proto(self, teamspace: "Teamspace", cloud_account: str, shared_filesystem: bool) -> V1PipelineStep:
+    def to_proto(
+        self, teamspace: "Teamspace", cloud_account: str, shared_filesystem: Union[bool, V1SharedFilesystem]
+    ) -> V1PipelineStep:
         _validate_cloud_account(cloud_account, self.cloud_account, shared_filesystem)
         return V1PipelineStep(
             name=self.name,
             type=V1PipelineStepType.DEPLOYMENT,
-            wait_for=to_wait_for(self.wait_for),
+            wait_for=_to_wait_for(self.wait_for),
             deployment=V1CreateDeploymentRequest(
                 autoscaling=to_autoscaling(self.autoscale, self.replicas),
                 endpoint=to_endpoint(self.ports, self.auth, self.custom_domain),
@@ -106,18 +119,20 @@ class Deployment:
                     machine=self.machine,
                     health_check=self.health_check,
                     quantity=self.quantity,
+                    cloudspace_id=self.studio._studio.id if self.studio else None,
+                    include_credentials=self.include_credentials,
                 ),
                 strategy=to_strategy(self.release_strategy),
             ),
         )
 
 
-class Job:
+class JobStep:
     # Note: This class is only temporary while pipeline is wip
 
     def __init__(
         self,
-        machine: Union["Machine", str],
+        machine: Optional[Union["Machine", str]] = None,
         name: Optional[str] = None,
         command: Optional[str] = None,
         studio: Union["Studio", str, None] = None,
@@ -132,17 +147,24 @@ class Job:
         cloud_account_auth: bool = False,
         entrypoint: str = "sh -c",
         path_mappings: Optional[Dict[str, str]] = None,
-        wait_for: Union[str, List[str]] = DEFAULT,
+        wait_for: Union[str, List[str], None] = DEFAULT,
     ) -> None:
         self.name = name
-        self.machine = machine
+        self.machine = machine or Machine.CPU
         self.command = command
-        self.studio = studio
+        self.studio = _get_studio(studio)
+
+        if cloud_account and self.studio and cloud_account != self.studio.cloud_account != cloud_account:
+            raise ValueError(
+                f"The provided cloud account `{cloud_account}` doesn't match"
+                f" the Studio cloud account {self.studio.cloud_account}"
+            )
+
         self.image = image
         self.teamspace = teamspace
         self.org = org
         self.user = user
-        self.cloud_account = cloud_account
+        self.cloud_account = cloud_account or "" if self.studio is None else self.studio.cloud_account
         self.env = env
         self.interruptible = interruptible
         self.image_credentials = image_credentials
@@ -151,7 +173,9 @@ class Job:
         self.path_mappings = path_mappings
         self.wait_for = wait_for
 
-    def to_proto(self, teamspace: "Teamspace", cloud_account: str, shared_filesystem: bool) -> V1PipelineStep:
+    def to_proto(
+        self, teamspace: "Teamspace", cloud_account: str, shared_filesystem: Union[bool, V1SharedFilesystem]
+    ) -> V1PipelineStep:
         studio = _get_studio(self.studio)
         if isinstance(studio, Studio):
             if self.cloud_account is None:
@@ -181,12 +205,12 @@ class Job:
         return V1PipelineStep(
             name=self.name,
             type=V1PipelineStepType.JOB,
-            wait_for=to_wait_for(self.wait_for),
+            wait_for=_to_wait_for(self.wait_for),
             job=body,
         )
 
 
-class MMT:
+class MMTStep:
     # Note: This class is only temporary while pipeline is wip
 
     def __init__(
@@ -207,18 +231,24 @@ class MMT:
         cloud_account_auth: bool = False,
         entrypoint: str = "sh -c",
         path_mappings: Optional[Dict[str, str]] = None,
-        wait_for: Union[str, List[str]] = DEFAULT,
+        wait_for: Optional[Union[str, List[str]]] = DEFAULT,
     ) -> None:
-        self.machine = machine
+        self.machine = machine or Machine.CPU
         self.num_machines = num_machines
         self.name = name
         self.command = command
-        self.studio = studio
+        self.studio = _get_studio(studio)
+
+        if cloud_account and self.studio and cloud_account != self.studio.cloud_account != cloud_account:
+            raise ValueError(
+                f"The provided cloud account `{cloud_account}` doesn't match"
+                f" the Studio cloud account {self.studio.cloud_account}"
+            )
         self.image = image
         self.teamspace = teamspace
         self.org = org
         self.user = user
-        self.cloud_account = cloud_account
+        self.cloud_account = cloud_account or "" if self.studio is None else self.studio.cloud_account
         self.env = env
         self.interruptible = interruptible
         self.image_credentials = image_credentials
@@ -227,7 +257,9 @@ class MMT:
         self.path_mappings = path_mappings
         self.wait_for = wait_for
 
-    def to_proto(self, teamspace: "Teamspace", cloud_account: str, shared_filesystem: bool) -> V1PipelineStep:
+    def to_proto(
+        self, teamspace: "Teamspace", cloud_account: str, shared_filesystem: Union[bool, V1SharedFilesystem]
+    ) -> V1PipelineStep:
         studio = _get_studio(self.studio)
         if isinstance(studio, Studio):
             if self.cloud_account is None:
@@ -258,37 +290,23 @@ class MMT:
         return V1PipelineStep(
             name=self.name,
             type=V1PipelineStepType.MMT,
-            wait_for=to_wait_for(self.wait_for),
+            wait_for=_to_wait_for(self.wait_for),
             mmt=body,
         )
 
 
-def to_wait_for(wait_for: Optional[Union[str, List[str]]]) -> Optional[List[str]]:
-    if wait_for == DEFAULT:
-        return wait_for
-
-    if wait_for is None:
-        return []
-
-    return wait_for if isinstance(wait_for, list) else [wait_for]
-
-
-def _validate_cloud_account(pipeline_cloud_account: str, step_cloud_account: str, shared_filesystem: bool) -> None:
-    if not shared_filesystem:
-        return
-
-    if pipeline_cloud_account != "" and step_cloud_account != "" and pipeline_cloud_account != step_cloud_account:
-        raise ValueError(
-            "With shared filesystem enabled, all the pipeline steps wait_for to be on the same cluster."
-            f" Found {pipeline_cloud_account} and {step_cloud_account}"
-        )
-
+class DeploymentReleaseStep(DeploymentStep):
+    def __init__(self, *args: Any, deployment_name: Optional[str] = None, **kwargs: Any) -> None:
+        if not deployment_name:
+            raise ValueError("The deployment name is required")
+        self._deployment_name = deployment_name
+        super().__init__(*args, **kwargs)
 
-def _get_studio(studio: Union["Studio", str, None]) -> Union[Studio, None]:
-    if studio is None:
-        return None
+    def to_proto(self, *args: Any, **kwargs: Any) -> V1PipelineStep:
+        proto: V1PipelineStep = super().to_proto(*args, **kwargs)
+        proto.deployment.name = self._deployment_name
+        proto.deployment.pipeline_reuse_deployment_between_runs = True
+        return proto
 
-    if isinstance(studio, Studio):
-        return studio
 
-    return Studio(studio)
+__all__ = ["JobStep", "MMTStep", "DeploymentStep", "DeploymentReleaseStep"]

lightning_sdk/pipeline/utils.py

@@ -1,6 +1,7 @@
-from typing import List
+from typing import List, Literal, Optional, Union
 
-from lightning_sdk.lightning_cloud.openapi.models import V1PipelineStep, V1PipelineStepType
+from lightning_sdk.lightning_cloud.openapi.models import V1PipelineStep, V1SharedFilesystem
+from lightning_sdk.studio import Studio
 
 DEFAULT = "DEFAULT"
 
@@ -51,19 +52,40 @@ def prepare_steps(steps: List["V1PipelineStep"]) -> List["V1PipelineStep"]:
                 if name_to_idx[name] >= name_to_idx[current_step.name]:
                     raise ValueError("You can only reference prior steps")
 
-    print()
-    print("===== Generated Pipeline =====")
-    for step_idx, step in enumerate(steps):
-        step_type = ""
-        if step.type == V1PipelineStepType.DEPLOYMENT:
-            step_type = "Deployment"
-        elif step.type == V1PipelineStepType.JOB:
-            step_type = "Job"
-        else:
-            step_type = "MMT"
-        wait_for = "nothing" if len(step.wait_for) == 0 else step.wait_for
-        print(f"{step_idx} - {step_type}['{step.name}'] wait_for {wait_for}")
-    print("===== ================== =====")
-    print()
-
     return steps
+
+
+def _get_studio(studio: Union["Studio", str, None]) -> Union[Studio, None]:
+    if studio is None:
+        return None
+
+    if isinstance(studio, Studio):
+        return studio
+
+    return Studio(studio)
+
+
+def _validate_cloud_account(
+    pipeline_cloud_account: str, step_cloud_account: str, shared_filesystem: Union[bool, V1SharedFilesystem]
+) -> None:
+    shared_filesystem_enable = (
+        shared_filesystem.enabled if isinstance(shared_filesystem, V1SharedFilesystem) else shared_filesystem
+    )
+    if not shared_filesystem_enable:
+        return
+
+    if pipeline_cloud_account != "" and step_cloud_account != "" and pipeline_cloud_account != step_cloud_account:
+        raise ValueError(
+            "With shared filesystem enabled, all the pipeline steps requires to be on the same cluster."
+            f" Found {pipeline_cloud_account} and {step_cloud_account}"
+        )
+
+
+def _to_wait_for(wait_for: Optional[Union[str, List[str]]]) -> Optional[Union[List[str], Literal["DEFAULT"]]]:
+    if wait_for == DEFAULT:
+        return wait_for
+
+    if wait_for is None:
+        return []
+
+    return wait_for if isinstance(wait_for, list) else [wait_for]

lightning_sdk/sandbox.py

@@ -0,0 +1,157 @@
+import ast
+import types
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional, Type, Union
+
+from lightning_sdk.machine import Machine
+from lightning_sdk.organization import Organization
+from lightning_sdk.status import Status
+from lightning_sdk.studio import Studio
+from lightning_sdk.teamspace import Teamspace
+from lightning_sdk.user import User
+
+
+@dataclass
+class Output:
+    text: str
+    exit_code: int
+
+
+class _Sandbox:
+    """Sandbox runs AI generated code safely and discards the machine after use.
+
+    Users can run any arbitrary code in a sandbox with sudo permissions.
+
+    Args:
+        name: The name of the sandbox.
+        machine: The machine to use for the sandbox.
+        interruptible: Whether the sandbox is interruptible.
+        teamspace: The teamspace to use for the sandbox.
+        org: The organization to use for the sandbox.
+        user: The user to use for the sandbox.
+        cloud_account: The cloud account to use for the sandbox.
+        disable_secrets: If true, user secrets such as LIGHTNING_API_KEY are not stored in the sandbox.
+
+    Example:
+        with Sandbox() as sandbox:
+            output = sandbox.run("python --version")
+            print(output.text)
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        machine: Optional[str] = None,
+        interruptible: Optional[bool] = None,
+        teamspace: Optional[Union[str, Teamspace]] = None,
+        org: Optional[Union[str, Organization]] = None,
+        user: Optional[Union[str, User]] = None,
+        cloud_account: Optional[str] = None,
+        disable_secrets: bool = True,
+    ) -> None:
+        if name is None:
+            timestr = datetime.now().strftime("%b-%d-%H_%M")
+            name = f"sandbox-{timestr}"
+
+        self._machine = machine or Machine.CPU
+        self._interruptible = interruptible
+        self._studio = Studio(
+            name=name,
+            teamspace=teamspace,
+            org=org,
+            user=user,
+            cloud_account=cloud_account,
+            disable_secrets=disable_secrets,
+        )
+
+    @property
+    def is_running(self) -> bool:
+        return self._studio.status == Status.Running
+
+    def start(self) -> None:
+        """Starts the sandbox if it is not already running."""
+        if self._studio.status == Status.Running:
+            raise RuntimeError(
+                "Cannot start sandbox: it is already running.\n\n"
+                "To ensure proper lifecycle management, either:\n"
+                "  • Avoid calling `start()` multiple times manually, or\n"
+                "  • Use the sandbox as a context manager:\n"
+                "      with Sandbox() as sandbox:\n"
+                "          # your code here\n"
+            )
+
+        if self._studio.status == Status.Pending:
+            raise RuntimeError("Cannot start sandbox: it is already starting. Wait for it to finish starting.")
+        self._studio.start(machine=self._machine, interruptible=self._interruptible)
+
+    def delete(self) -> None:
+        """Deletes the sandbox if it is not already deleted."""
+        if self._studio.status == Status.NotCreated:
+            raise RuntimeError("Cannot delete sandbox: it is not created.")
+        self._studio.delete()
+
+    def run(self, command: str) -> Output:
+        """Runs the command and returns the output."""
+        output, exit_code = self._studio.run_with_exit_code(command)
+        if exit_code != 0:
+            raise Exception(f"Command failed with exit code {exit_code}: {output}")
+        return Output(text=output, exit_code=exit_code)
+
+    @staticmethod
+    def _validate_python_code(code: str) -> None:
+        """Validates Python code for syntax errors.
+
+        Args:
+            code: The Python code string to validate
+
+        Raises:
+            SyntaxError: If the code has syntax errors
+            ValueError: If the code is empty or only whitespace
+            IndentationError: If the code has improper indentation
+
+        Note:
+            This validation only catches syntax-level errors. Runtime errors like
+            NameError or TypeError can only be caught when the code is actually executed.
+        """
+        if not code or not code.strip():
+            raise ValueError("Code cannot be empty or only whitespace")
+
+        try:
+            ast.parse(code)
+        except (SyntaxError, IndentationError) as e:
+            error_type = type(e).__name__
+            raise type(e)(f"Invalid Python {error_type.lower()}: {e}") from e
+
+    def run_python_code(self, code: str) -> Output:
+        """Runs the python code and returns the output.
+
+        Args:
+            code: The Python code string to execute
+
+        Returns:
+            Output: The result of executing the code
+
+        Raises:
+            SyntaxError: If the code has syntax errors
+            ValueError: If the code is empty or only whitespace
+        """
+        # Validate the code before running
+        self._validate_python_code(code)
+
+        command = f"python - <<EOF\n{code}\nEOF"
+        return self.run(command)
+
+    def __enter__(self) -> "_Sandbox":
+        """Starts the sandbox if it is not running and returns the sandbox."""
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[types.TracebackType] = None,
+    ) -> None:
+        """Deletes the sandbox after use."""
+        self._studio.delete()

lightning_sdk/services/license.py

@@ -39,8 +39,8 @@ MESSAGE_GUIDE_SIGN_LICENSE = (
     "│ Details: license key ({license_strats}...{license_ends}) for package {package_name:<56} │\n"
     "│ Please make sure you have signed the license agreement and set the license key.                           │\n"
     "│                                                                                                           │\n"
-    f"│ Sign the license agreement here (if you dont have Lightning account, you will asked to create one):       │\n"
-    f"│   {generate_url_user_settings():<102}\n"
+    "│ Sign the license agreement here (if you dont have Lightning account, you will asked to create one):       │\n"
+    "│   {link}\n"
     "│                                                                                                           │\n"
     "│ Once you have the license key, you may need to reinstall this package to activate it. Use the commands:   │\n"
     "│                                                                                                           │\n"
@@ -57,6 +57,7 @@ def generate_message_guide_sign_license(package_name: str, reason: str, license_
     if not license_key:
         license_key = "." * 64
     return MESSAGE_GUIDE_SIGN_LICENSE.format(
+        link=generate_url_user_settings(name=package_name),
         package_name=package_name,
         reason=reason.ljust(102, " "),
         license_strats=license_key[:5],
@@ -273,12 +274,17 @@ class LightningLicense:
     @property
     def license_key(self) -> Optional[str]:
         """Get the license key."""
+        name = self.product_name.replace("-", "_")
+        if not self._license_key:
+            # If the license key is not set, first try to find it env variables
+            self._license_key = os.environ.get(f"LIGHTNING_{name.upper()}_LICENSE_KEY", None)
+        if not self._license_key:
+            # If the license key is not set, second try to find it in the package root
+            self._license_key = self._find_package_license_key(name)
+        # If not found, try to find it in the user home
         if not self._license_key:
-            # If the license key is not set, fist try to find it in the package root
-            self._license_key = self._find_package_license_key(self.product_name.replace("-", "_"))
             # If not found, try to find it in the user home
-            if not self._license_key:
-                self._license_key = self._find_user_license_key(self.product_name)
+            self._license_key = self._find_user_license_key(self.product_name)
         return self._license_key
 
     @property