lightning-sdk 0.2.18__py3-none-any.whl → 0.2.20__py3-none-any.whl

lightning_sdk/services/license.py

@@ -3,11 +3,79 @@ import json
 import os
 import socket
 import threading
+from contextlib import suppress
 from functools import partial
+from importlib import metadata
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
-from lightning_sdk.api.license_api import LicenseApi
+from lightning_sdk.api.license_api import LICENSE_SIGNING_URL, LicenseApi, generate_url_user_settings
+from lightning_sdk.lightning_cloud.login import Auth
+
+MESSAGE_NOT_AUTHENTICATED = (
+    "┌─────────────────────────────────────────────────────────────────────────┐\n"
+    "│ ⚠️  No authenticated user found or license API is not available.        │\n"
+    "│                                                                         │\n"
+    "│   Please make sure you are logged in and have a valid license.          │\n"
+    "│   If you're not logged in, you can use the following command:           │\n"
+    "│                                                                         │\n"
+    "│     lightning login                                                     │\n"
+    "└─────────────────────────────────────────────────────────────────────────┘"
+)
+MESSAGE_AUTH_NO_LICENSE = (
+    "┌──────────────────────────────────────────────────────────────────────────────────────────────┐\n"
+    "│ ⚠️ No valid license found for the authenticated user for product '{self.product_name}'.      │\n"
+    "│                                                                                              │\n"
+    "│   Please ensure you have an approved license for this product.                               │\n"
+    "│   If you believe this is an error, please contact support.                                   │\n"
+    "│                                                                                              │\n"
+    "│   You can review or update your license settings here:                                       │\n"
+    f"│     {LICENSE_SIGNING_URL:<89}│\n"
+    "└──────────────────────────────────────────────────────────────────────────────────────────────┘"
+)
+MESSAGE_GUIDE_SIGN_LICENSE = (
+    "┌───────────────────────────────────────────────────────────────────────────────────────────────────────────┐\n"
+    "│ ⚠️ {reason} │\n"
+    "│ 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"
+    "│                                                                                                           │\n"
+    "│ Once you have the license key, you may need to reinstall this package to activate it. Use the commands:   │\n"
+    "│                                                                                                           │\n"
+    "│   export LIGHTNING_LICENSE_KEY=<your_license_key>                                                         │\n"
+    "│   pip install --force-reinstall --no-deps {package_name:<63} │\n"
+    "│                                                                                                           │\n"
+    "│ For more information, please refer to the documentation.                                                  │\n"
+    "└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘"
+)
+
+
+def generate_message_guide_sign_license(package_name: str, reason: str, license_key: str = "") -> str:
+    """Generate a default message for signing the license agreement."""
+    if not license_key:
+        license_key = "." * 64
+    return MESSAGE_GUIDE_SIGN_LICENSE.format(
+        package_name=package_name,
+        reason=reason.ljust(102, " "),
+        license_strats=license_key[:5],
+        license_ends=license_key[-5:],
+    )
+
+
+MESSAGE_WITH_KEY_OFFLINE = (
+    "┌──────────────────────────────────────────────────────────────────────────────────────┐\n"
+    "│ ⚠️ License key ({license_strats}...{license_ends}) is set, but the system is offline.                    │\n"
+    "│                                                                                      │\n"
+    "│ Please ensure your license key is valid and that the system is connected online.     │\n"
+    "└──────────────────────────────────────────────────────────────────────────────────────┘"
+)
+
+
+def generate_message_with_key_offline(license_key: str) -> str:
+    """Generate a message for when the license key is set but the system is offline."""
+    return MESSAGE_WITH_KEY_OFFLINE.format(license_strats=license_key[:5], license_ends=license_key[-5:])
 
 
 class LightningLicense:
@@ -33,19 +101,57 @@ class LightningLicense:
         self._license_api = None
         self._stream_messages = stream_messages
 
+    @property
+    def license_api(self) -> LicenseApi:
+        """Get the LicenseApi instance."""
+        if not self._license_api:
+            with suppress(ValueError):
+                self._license_api = LicenseApi()
+        return self._license_api
+
     def validate_license(self) -> bool:
         """Validate the license key."""
         if not self.is_online():
             raise ConnectionError("No internet connection.")
 
-        self._license_api = LicenseApi()
-        return self._license_api.valid_license(
+        return self.license_api.valid_license(
             license_key=self.license_key,
             product_name=self.product_name,
             product_version=self.product_version,
             product_type=self.product_type,
         )
 
+    def _auth_user_id(self) -> Tuple[Optional[str], Optional[str]]:
+        """Get the authenticated user ID."""
+        try:
+            auth = Auth()
+        except ValueError:
+            return None, "No user credentials found. Please run `lightning login` to authenticate."
+        return auth.user_id, None
+
+    def _check_user_license(self, user_id: Optional[str] = None) -> bool:
+        """Check if the authenticated user has a valid license for this product."""
+        if not user_id:
+            user_id, msg = self._auth_user_id()
+            if msg:
+                self._stream_messages(msg)
+            if not user_id:
+                return False
+        if not self.license_api:
+            self._stream_messages(MESSAGE_NOT_AUTHENTICATED)
+            return False
+
+        licenses = self.license_api.list_user_licenses(user_id=user_id)
+        for license_info in licenses:
+            if (
+                license_info.product_name == self.product_name
+                and license_info.product_type == self.product_type
+                and license_info.is_valid
+            ):
+                return True
+        self._stream_messages(MESSAGE_AUTH_NO_LICENSE)
+        return False
+
     @staticmethod
     def is_online(timeout: float = 2.0) -> bool:
         """Check if the system is online by attempting to connect to a public DNS server (Google's).
@@ -75,22 +181,33 @@ class LightningLicense:
         if isinstance(self._is_valid, bool):
             # if the license key is already validated, return the cached value
             return self._is_valid
-        if not self.product_version:
-            self._stream_messages("Product version is not set correctly, consider leave it empty for auto-determine.")
-        if not self.license_key:
-            self._stream_messages(
-                "License key is not set neither cannot be found in the package root or user home."
-                " Please make sure you have signed the license agreement and set the license key."
-                " For more information, please refer to the documentation.",
-            )
         is_online = self.is_online()
-        if self.license_key and is_online:
-            self._is_valid = self.validate_license()
-        elif not is_online:
+        if is_online:
+            if self.license_key:
+                self._is_valid = self.validate_license()
+            else:
+                # try to check if the session has logged-in user and if the user has a valid license
+                self._stream_messages(
+                    "Missing required license key for license validation."
+                    f" Attempting to check if the authenticated user has a valid license for {self.product_name}."
+                )
+                user_id, auth_msg = self._auth_user_id()
+                if not user_id:
+                    self._is_valid = False
+                    if auth_msg:
+                        self._stream_messages(auth_msg)
+                else:
+                    self._is_valid = self._check_user_license(user_id=user_id)
+        elif self.license_key:
+            self._stream_messages(generate_message_with_key_offline(self.license_key))
+        else:
             self._stream_messages(
-                "License key is set but the system is offline. "
-                "Please make sure you have a valid license key and the system is online."
+                generate_message_guide_sign_license(
+                    package_name=self.product_name,
+                    reason="License key is not set neither cannot be found in the package root or user home.",
+                )
             )
+
         return self._is_valid
 
     @property
@@ -107,14 +224,17 @@ class LightningLicense:
         """
         if not package_name:
             return None
+        pkg_spec = importlib.util.find_spec(package_name)
+        if pkg_spec is None:
+            return None
+        pkg_locations = pkg_spec.submodule_search_locations
+        if not pkg_locations:
+            return None
         try:
-            pkg_locations = importlib.util.find_spec(package_name).submodule_search_locations
-            if not pkg_locations:
-                return None
             license_file = os.path.join(pkg_locations[0], ".license_key")
             with open(license_file) as fp:
                 return fp.read().strip()
-        except (FileNotFoundError, ModuleNotFoundError):
+        except FileNotFoundError:
             return None
 
     @staticmethod
@@ -146,9 +266,8 @@ class LightningLicense:
             package_name: The name of the package. If not provided, it will be determined from the current module.
         """
         try:
-            pkg = importlib.import_module(package_name)
-            return getattr(pkg, "__version__", None)
-        except ImportError:
+            return metadata.version(package_name)
+        except metadata.PackageNotFoundError:
             return None
 
     @property
@@ -200,9 +319,11 @@ def check_license(
     )
     if lit_license.is_valid is False:
         stream_messages(
-            "License key is not valid.\n"
-            f" Key: {lit_license.license_key}\n"
-            " Please make sure you have a valid license key."
+            generate_message_guide_sign_license(
+                package_name=lit_license.product_name,
+                reason="License key is not valid or not set.",
+                license_key=lit_license.license_key,
+            )
         )
 
 

{lightning_sdk-0.2.18.dist-info → lightning_sdk-0.2.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightning_sdk
-Version: 0.2.18
+Version: 0.2.20
 Summary: SDK to develop using Lightning AI Studios
 Author-email: Lightning-AI <justus@lightning.ai>
 License: MIT License