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

lightning_sdk/api/deployment_api.py

@@ -1,7 +1,7 @@
 from time import sleep
-from typing import Any, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
-from lightning_sdk.api.utils import _MACHINE_TO_COMPUTE_NAME
+from lightning_sdk.api.utils import _machine_to_compute_name, resolve_path_mappings
 from lightning_sdk.lightning_cloud.openapi import (
     CreateDeploymentRequestDefinesASpecForTheJobThatAllowsForAutoscalingJobs,
     V1AutoscalingSpec,
@@ -58,6 +58,10 @@ class TokenAuth(Auth):
         self.token = token
 
 
+class ApiKeyAuth(Auth):
+    """The ApiKeyAuth describes that the user requires a Lightning API Key to authenticate."""
+
+
 class ReleaseStrategy:
     """The base class for release strategy."""
 
@@ -102,10 +106,10 @@ class ExecHealthCheck(HealthCheck):
     def __init__(
         self,
         command: str,
-        timeout_seconds: int = 60,
-        initial_delay_seconds: int = 5,
-        failure_threshold: int = 12,
-        interval_seconds: int = 5,
+        initial_delay_seconds: int = 0,
+        failure_threshold: int = 3600,
+        interval_seconds: int = 1,
+        timeout_seconds: int = 30,
     ) -> None:
         self.command = command
         self.timeout_seconds = timeout_seconds
@@ -131,17 +135,17 @@ class HttpHealthCheck(HealthCheck):
         self,
         path: str,
         port: float,
-        timeout_seconds: int = 60,
-        initial_delay_seconds: int = 5,
-        failure_threshold: int = 12,
-        interval_seconds: int = 5,
+        initial_delay_seconds: int = 0,
+        failure_threshold: int = 3600,
+        interval_seconds: int = 1,
+        timeout_seconds: int = 30,
     ) -> None:
         self.path = path
         self.port = port
-        self.timeout_seconds = timeout_seconds
         self.initial_delay_seconds = initial_delay_seconds
         self.failure_threshold = failure_threshold
         self.interval_seconds = interval_seconds
+        self.timeout_seconds = timeout_seconds
 
 
 class AutoScalingMetric:
@@ -213,13 +217,24 @@ class DeploymentApi:
                 return None
             raise ex
 
+    def get_deployment_by_id(self, deployment_id: str, teamspace_id: str) -> Optional[V1Deployment]:
+        try:
+            return self._client.jobs_service_get_deployment(project_id=teamspace_id, id=deployment_id)
+        except ApiException as ex:
+            if "Reason: Not Found" in str(ex):
+                return None
+            raise ex
+
     def create_deployment(
         self,
         deployment: V1Deployment,
+        from_onboarding: Optional[bool] = None,
+        from_litserve: Optional[bool] = None,
     ) -> V1Deployment:
         return self._client.jobs_service_create_deployment(
             project_id=deployment.project_id,
             body=CreateDeploymentRequestDefinesASpecForTheJobThatAllowsForAutoscalingJobs(
+                cloudspace_id=deployment.cloudspace_id,
                 autoscaling=deployment.autoscaling,
                 cluster_id=deployment.spec.cluster_id,
                 endpoint=deployment.endpoint,
@@ -227,6 +242,8 @@ class DeploymentApi:
                 replicas=deployment.replicas,
                 spec=deployment.spec,
                 strategy=deployment.strategy,
+                from_onboarding=from_onboarding,
+                from_litserve=from_litserve,
             ),
         )
 
@@ -234,7 +251,7 @@ class DeploymentApi:
         self,
         deployment: V1Deployment,
         machine: Optional[Machine] = None,
-        environment: Optional[str] = None,
+        image: Optional[str] = None,
         entrypoint: Optional[str] = None,
         command: Optional[str] = None,
         env: Optional[List[Union[Env, Secret]]] = None,
@@ -249,6 +266,10 @@ class DeploymentApi:
         health_check: Optional[Union[HttpHealthCheck, ExecHealthCheck]] = None,
         auth: Optional[Union[BasicAuth, TokenAuth]] = None,
         custom_domain: Optional[str] = None,
+        quantity: Optional[int] = None,
+        include_credentials: Optional[bool] = None,
+        max_runtime: Optional[int] = None,
+        path_mappings: Optional[Dict[str, str]] = None,
     ) -> V1Deployment:
         # Update the deployment in place
 
@@ -262,21 +283,37 @@ class DeploymentApi:
 
         # Any updates to the Job Spec triggers a new release
         if machine:
-            apply_change(deployment.spec, "instance_name", _MACHINE_TO_COMPUTE_NAME[machine])
+            apply_change(deployment.spec, "instance_name", _machine_to_compute_name(machine))
+            apply_change(deployment.spec, "instance_type", _machine_to_compute_name(machine))
 
         requires_release = False
-        requires_release |= apply_change(deployment.spec, "image", environment)
+        requires_release |= apply_change(deployment.spec, "image", image)
+
+        if path_mappings:
+            requires_release |= apply_change(
+                deployment.spec, "path_mappings", resolve_path_mappings(path_mappings, None, None)
+            )
+
         requires_release |= apply_change(deployment.spec, "entrypoint", entrypoint)
         requires_release |= apply_change(deployment.spec, "command", command)
         requires_release |= apply_change(deployment.spec, "env", to_env(env))
-        requires_release |= apply_change(deployment.spec, "env", to_health_check(health_check))
+        requires_release |= apply_change(deployment.spec, "readiness_probe", to_health_check(health_check, False))
         requires_release |= apply_change(deployment.spec, "cluster_id", cloud_account)
         requires_release |= apply_change(deployment.spec, "spot", spot)
+        requires_release |= apply_change(deployment.spec, "quantity", quantity)
+        requires_release |= apply_change(deployment.spec, "include_credentials", include_credentials)
+        requires_release |= apply_change(
+            deployment.spec, "requested_run_duration_seconds", str(max_runtime) if max_runtime is not None else None
+        )
 
         if requires_release:
             if deployment.strategy is None:
                 raise RuntimeError("When doing a new release, a release strategy needs to be defined.")
 
+            # Force the deployment to make a new snapshot
+            if deployment.spec.cloudspace_id != "" and deployment.spec.run_id != "":
+                deployment.spec.run_id = ""
+
             print("Some core arguments have changed. We are making a new release.")
 
         apply_change(deployment.endpoint, "custom_domain", custom_domain)
@@ -348,11 +385,15 @@ def restore_auth(auth: Optional[V1EndpointAuth] = None) -> Optional[Auth]:
     if not auth:
         return None
 
+    if auth.user_api_key:
+        return ApiKeyAuth()
+
     if auth.username and auth.password:
         return BasicAuth(username=auth.username, password=auth.password)
 
     if auth.token:
         return TokenAuth(token=auth.token)
+
     return None
 
 
@@ -373,13 +414,21 @@ def restore_env(env: List[V1EnvVar]) -> List[Union[Secret, Env]]:
     return [Secret(name=e.from_secret) if e.from_secret else Env(name=e.name, value=e.value) for e in env]
 
 
-def to_env(env: Optional[List[Union[Secret, Env]]] = None) -> Optional[List[V1EnvVar]]:
+def to_env(env: Union[List[Union[Secret, Env]], Dict[str, str], None] = None) -> Optional[List[V1EnvVar]]:
     if not env:
         return None
 
+    env_list = []
+
+    if isinstance(env, dict):
+        for k, v in env.items():
+            env_list.append(Env(name=k, value=v))
+    else:
+        env_list = env
+
     return [
         V1EnvVar(name=env.name, value=env.value) if isinstance(env, Env) else V1EnvVar(from_secret=env.name)
-        for env in env
+        for env in env_list
     ]
 
 
@@ -436,7 +485,7 @@ def to_autoscaling(
     if target_metrics is None and (threshold < 0 or threshold > 100):
         raise ValueError("The autoscaling threshold should be defined between 0 and 100.")
 
-    if target_metrics is not None and len(target_metrics) == 0:
+    if target_metrics is not None and len(target_metrics) == 0 and metric is None:
         raise ValueError("The target_metrics must be provided.")
 
     if target_metrics is not None:
@@ -450,7 +499,7 @@ def to_autoscaling(
             target_metric.target = str(target_metric.target)
 
     metrics = (
-        target_metrics
+        [V1AutoscalingTargetMetric(name=t.name, target=t.target) for t in target_metrics]
         if target_metrics is not None
         else [V1AutoscalingTargetMetric(name=metric, target=str(threshold))]
     )
@@ -481,6 +530,10 @@ def to_endpoint_auth(auth: Optional[Auth] = None) -> Optional[V1EndpointAuth]:
             raise ValueError("The token should be defined.")
 
         return V1EndpointAuth(enabled=True, token=auth.token)
+
+    if isinstance(auth, ApiKeyAuth):
+        return V1EndpointAuth(enabled=True, user_api_key=True)
+
     return None
 
 
@@ -498,11 +551,21 @@ def to_endpoint(
 
 
 def to_health_check(
-    health_check: Optional[Union[HttpHealthCheck, ExecHealthCheck]] = None
+    health_check: Optional[Union[HttpHealthCheck, ExecHealthCheck]] = None,
+    use_default: bool = True,
 ) -> Optional[V1JobHealthCheckConfig]:
-    if not health_check:
+    if health_check is None and not use_default:
         return None
 
+    # Use Default health check if none is provided
+    if not health_check:
+        return V1JobHealthCheckConfig(
+            failure_threshold=3600,
+            initial_delay_seconds=0,
+            interval_seconds=1,
+            timeout_seconds=60,
+        )
+
     health_check_config = V1JobHealthCheckConfig(
         failure_threshold=health_check.failure_threshold,
         initial_delay_seconds=health_check.initial_delay_seconds,
@@ -523,12 +586,18 @@ def to_health_check(
 def to_spec(
     cloud_account: Optional[str],
     machine: Optional[Machine],
-    environment: Optional[str],
+    image: Optional[str],
     entrypoint: Optional[str],
     command: Optional[str],
     spot: Optional[bool] = False,
-    env: Optional[List[Union[Secret, Env]]] = None,
+    env: Union[List[Union[Secret, Env]], Dict[str, str], None] = None,
     health_check: Optional[Union[HttpHealthCheck, ExecHealthCheck]] = None,
+    quantity: Optional[int] = None,
+    include_credentials: Optional[bool] = None,
+    cloudspace_id: Optional[None] = None,
+    max_runtime: Optional[int] = None,
+    machine_image_version: Optional[str] = None,
+    path_mappings: Optional[Dict[str, str]] = None,
 ) -> V1JobSpec:
     if cloud_account is None:
         raise ValueError("The cloud account should be defined.")
@@ -536,18 +605,37 @@ def to_spec(
     if machine is None:
         raise ValueError("The machine should be defined.")
 
-    if environment is None:
-        raise ValueError("The environment should be defined.")
+    if image is None and cloudspace_id is None:
+        raise ValueError("The image should be defined.")
+
+    if entrypoint is not None and cloudspace_id is not None:
+        raise ValueError("The entrypoint shouldn't be defined when a Studio is provided.")
+
+    if command is None and cloudspace_id is not None:
+        raise ValueError("The command should be defined.")
+
+    # need to go via kwargs for typing compatibility since autogenerated apis accept None but aren't typed with None
+    optional_spec_kwargs = {}
+    if max_runtime:
+        optional_spec_kwargs["requested_run_duration_seconds"] = str(max_runtime)
+
+    path_mapping_list = resolve_path_mappings(path_mappings or {}, None, None)
 
     return V1JobSpec(
         cluster_id=cloud_account,
         command=command,
         entrypoint=entrypoint,
         env=to_env(env),
-        image=environment,
+        image=image,
         spot=spot,
-        instance_name=_MACHINE_TO_COMPUTE_NAME[machine],
+        instance_name=_machine_to_compute_name(machine),
         readiness_probe=to_health_check(health_check),
+        quantity=quantity,
+        include_credentials=include_credentials,
+        cloudspace_id=cloudspace_id,
+        machine_image_version=machine_image_version,
+        path_mappings=path_mapping_list,
+        **optional_spec_kwargs,
     )
 
 
@@ -572,3 +660,21 @@ def apply_change(spec: Any, key: str, value: Any) -> bool:
         return True
 
     return False
+
+
+def compose_commands(commands: List[str]) -> str:
+    composite_command = []
+
+    for command in commands:
+        command = command.strip()
+
+        # Check if the command already has '&'
+        if command.endswith("&"):
+            # It's a background command, add it as a subshell without further adjustment
+            composite_command.append(f"( {command} )")
+        else:
+            # Sequential execution, add as-is and use `&&` to connect if followed by another command
+            composite_command.append(command)
+
+    # Joining commands, using `&&` between sequential parts and respecting subshell backgrounds
+    return " && ".join(composite_command)

lightning_sdk/api/job_api.py

@@ -1,16 +1,14 @@
 import time
-from typing import TYPE_CHECKING, Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
 from urllib.request import urlopen
 
 from lightning_sdk.api.utils import (
-    _COMPUTE_NAME_TO_MACHINE,
-    _MACHINE_TO_COMPUTE_NAME,
     _create_app,
+    _machine_to_compute_name,
     remove_datetime_prefix,
+    resolve_path_mappings,
 )
-from lightning_sdk.api.utils import (
-    _get_cloud_url as _cloud_url,
-)
+from lightning_sdk.api.utils import _get_cloud_url as _cloud_url
 from lightning_sdk.constants import __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__
 from lightning_sdk.lightning_cloud.openapi import (
     AppinstancesIdBody,
@@ -19,7 +17,7 @@ from lightning_sdk.lightning_cloud.openapi import (
     JobsIdBody1,
     ProjectIdJobsBody,
     V1CloudSpace,
-    V1ComputeConfig,
+    V1ClusterAccelerator,
     V1DownloadJobLogsResponse,
     V1DownloadLightningappInstanceLogsResponse,
     V1EnvVar,
@@ -96,16 +94,49 @@ class JobApiV1:
     def get_work(self, job_id: str, teamspace_id: str, work_id: str) -> Externalv1Lightningwork:
         return self._client.lightningwork_service_get_lightningwork(project_id=teamspace_id, app_id=job_id, id=work_id)
 
-    def get_machine_from_work(self, work: Externalv1Lightningwork) -> Machine:
+    def get_machine_from_work(self, work: Externalv1Lightningwork, org_id: str) -> Machine:
         spec: V1LightningworkSpec = work.spec
         # prefer user-requested config if specified
-        compute_config: V1UserRequestedComputeConfig = spec.user_requested_compute_config
-        compute: str = compute_config.name
-        if compute:
-            return _COMPUTE_NAME_TO_MACHINE[compute]
-        compute_config: V1ComputeConfig = spec.compute_config
-        compute: str = compute_config.instance_type
-        return _COMPUTE_NAME_TO_MACHINE[compute]
+        user_requested_compute_config: V1UserRequestedComputeConfig = spec.user_requested_compute_config
+        accelerators = self._get_machines_for_cloud_account(
+            teamspace_id=work.project_id,
+            cloud_account_id=spec.cluster_id,
+            org_id=org_id,
+        )
+
+        identifiers = []
+
+        if user_requested_compute_config and user_requested_compute_config.name:
+            identifiers.append(user_requested_compute_config.name)
+        else:
+            identifiers.append(spec.compute_config.instance_type)
+
+        for accelerator in accelerators:
+            for ident in identifiers:
+                if ident in (
+                    accelerator.slug,
+                    accelerator.slug_multi_cloud,
+                    accelerator.instance_id,
+                ):
+                    return Machine._from_accelerator(accelerator)
+
+        return Machine.from_str(identifiers[0])
+
+    def _get_machines_for_cloud_account(
+        self, teamspace_id: str, cloud_account_id: str, org_id: str
+    ) -> List[V1ClusterAccelerator]:
+        from lightning_sdk.api.cloud_account_api import CloudAccountApi
+
+        cloud_account_api = CloudAccountApi()
+        accelerators = cloud_account_api.list_cloud_account_accelerators(
+            teamspace_id=teamspace_id,
+            cloud_account_id=cloud_account_id,
+            org_id=org_id,
+        )
+        if not accelerators:
+            return []
+
+        return list(filter(lambda acc: acc.enabled, accelerators.accelerator))
 
     def get_studio_name(self, job: Externalv1LightningappInstance) -> str:
         cs: V1CloudSpace = self._client.cloud_space_service_get_cloud_space(
@@ -120,7 +151,7 @@ class JobApiV1:
         studio_id: str,
         teamspace_id: str,
         cloud_account: str,
-        machine: Machine,
+        machine: Union[Machine, str],
         interruptible: bool,
     ) -> Externalv1LightningappInstance:
         """Creates an arbitrary app."""
@@ -130,7 +161,7 @@ class JobApiV1:
             teamspace_id=teamspace_id,
             cloud_account=cloud_account,
             plugin_type="job",
-            compute=_MACHINE_TO_COMPUTE_NAME[machine],
+            compute=_machine_to_compute_name(machine),
             name=name,
             entrypoint=command,
             interruptible=interruptible,
@@ -209,23 +240,79 @@ class JobApiV2:
         teamspace_id: str,
         studio_id: Optional[str],
         image: Optional[str],
-        machine: Machine,
+        machine: Union[Machine, str],
         interruptible: bool,
         env: Optional[Dict[str, str]],
         image_credentials: Optional[str],
         cloud_account_auth: bool,
-        artifacts_local: Optional[str],
-        artifacts_remote: Optional[str],
         entrypoint: str,
+        path_mappings: Optional[Dict[str, str]],
+        artifacts_local: Optional[str],  # deprecated in favor of path_mappings
+        artifacts_remote: Optional[str],  # deprecated in favor of path_mappings
+        max_runtime: Optional[int] = None,
+        reuse_snapshot: bool = True,
     ) -> V1Job:
+        body = self._create_job_body(
+            name=name,
+            command=command,
+            cloud_account=cloud_account,
+            studio_id=studio_id,
+            image=image,
+            machine=machine,
+            interruptible=interruptible,
+            env=env,
+            image_credentials=image_credentials,
+            cloud_account_auth=cloud_account_auth,
+            entrypoint=entrypoint,
+            path_mappings=path_mappings,
+            artifacts_local=artifacts_local,
+            artifacts_remote=artifacts_remote,
+            max_runtime=max_runtime,
+            reuse_snapshot=reuse_snapshot,
+        )
+
+        job: V1Job = self._client.jobs_service_create_job(project_id=teamspace_id, body=body)
+        return job
+
+    @staticmethod
+    def _create_job_body(
+        name: str,
+        command: Optional[str],
+        cloud_account: Optional[str],
+        studio_id: Optional[str],
+        image: Optional[str],
+        machine: Union[Machine, str],
+        interruptible: bool,
+        env: Optional[Dict[str, str]],
+        image_credentials: Optional[str],
+        cloud_account_auth: bool,
+        entrypoint: str,
+        path_mappings: Optional[Dict[str, str]],
+        artifacts_local: Optional[str],  # deprecated in favor of path_mappings
+        artifacts_remote: Optional[str],  # deprecated in favor of path_mappings)
+        reuse_snapshot: bool,
+        max_runtime: Optional[int] = None,
+        machine_image_version: Optional[str] = None,
+    ) -> ProjectIdJobsBody:
         env_vars = []
         if env is not None:
             for k, v in env.items():
                 env_vars.append(V1EnvVar(name=k, value=v))
 
-        instance_name = _MACHINE_TO_COMPUTE_NAME[machine]
+        instance_name = _machine_to_compute_name(machine)
+
+        run_id = __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__[studio_id] if (studio_id is not None and reuse_snapshot) else ""
 
-        run_id = __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__[studio_id] if studio_id is not None else ""
+        path_mappings_list = resolve_path_mappings(
+            mappings=path_mappings or {},
+            artifacts_local=artifacts_local,
+            artifacts_remote=artifacts_remote,
+        )
+
+        # need to go via kwargs for typing compatibility since autogenerated apis accept None but aren't typed with None
+        optional_spec_kwargs = {}
+        if max_runtime:
+            optional_spec_kwargs["requested_run_duration_seconds"] = str(max_runtime)
 
         spec = V1JobSpec(
             cloudspace_id=studio_id or "",
@@ -239,13 +326,11 @@ class JobApiV2:
             spot=interruptible,
             image_cluster_credentials=cloud_account_auth,
             image_secret_ref=image_credentials or "",
-            artifacts_source=artifacts_local or "",
-            artifacts_destination=artifacts_remote or "",
+            path_mappings=path_mappings_list,
+            machine_image_version=machine_image_version,
+            **optional_spec_kwargs,
         )
-        body = ProjectIdJobsBody(name=name, spec=spec)
-
-        job: V1Job = self._client.jobs_service_create_job(project_id=teamspace_id, body=body)
-        return job
+        return ProjectIdJobsBody(name=name, spec=spec)
 
     def get_job_by_name(self, name: str, teamspace_id: str) -> V1Job:
         job: V1Job = self._client.jobs_service_find_job(project_id=teamspace_id, name=name)
@@ -270,7 +355,7 @@ class JobApiV2:
             return
 
         if current_state != Status.Stopping:
-            update_body = JobsIdBody1(cloudspace_id=current_job.spec.cloudspace_id, state=self.v2_job_state_stop)
+            update_body = JobsIdBody1(state=self.v2_job_state_stop)
             self._client.jobs_service_update_job(body=update_body, project_id=teamspace_id, id=job_id)
 
         while True:
@@ -334,13 +419,41 @@ class JobApiV2:
             return Status.Stopping
         return Status.Pending
 
-    def _get_job_machine_from_spec(self, spec: V1JobSpec) -> "Machine":
-        instance_name = spec.instance_name
-        instance_type = spec.instance_type
+    def _get_job_machine_from_spec(self, spec: V1JobSpec, teamspace_id: str, org_id: str) -> "Machine":
+        accelerators = self._get_machines_for_cloud_account(
+            teamspace_id=teamspace_id,
+            cloud_account_id=spec.cluster_id,
+            org_id=org_id,
+        )
 
-        return _COMPUTE_NAME_TO_MACHINE.get(
-            instance_type, _COMPUTE_NAME_TO_MACHINE.get(instance_name, instance_type or instance_name)
+        for accelerator in accelerators:
+            possible_identifiers = (
+                accelerator.slug,
+                accelerator.slug_multi_cloud,
+                accelerator.instance_id,
+            )
+            if (spec.instance_name and spec.instance_name in possible_identifiers) or (
+                spec.instance_type and spec.instance_type in possible_identifiers
+            ):
+                return Machine._from_accelerator(accelerator)
+
+        return Machine.from_str(spec.instance_name or spec.instance_type)
+
+    def _get_machines_for_cloud_account(
+        self, teamspace_id: str, cloud_account_id: str, org_id: str
+    ) -> List[V1ClusterAccelerator]:
+        from lightning_sdk.api.cloud_account_api import CloudAccountApi
+
+        cloud_account_api = CloudAccountApi()
+        accelerators = cloud_account_api.list_cloud_account_accelerators(
+            teamspace_id=teamspace_id,
+            cloud_account_id=cloud_account_id,
+            org_id=org_id,
         )
+        if not accelerators:
+            return []
+
+        return list(filter(lambda acc: acc.enabled, accelerators.accelerator))
 
     def get_total_cost(self, job: V1Job) -> float:
         return job.total_cost

lightning_sdk/api/license_api.py

@@ -0,0 +1,37 @@
+from lightning_sdk.api.utils import _get_cloud_url as _cloud_url
+from lightning_sdk.lightning_cloud.login import Auth
+from lightning_sdk.lightning_cloud.openapi import LicenseKeyValidateBody, ProductLicenseServiceApi
+
+
+class LicenseApi:
+    def __init__(self, login_token: str) -> None:
+        self._cloud_url = _cloud_url()
+        self._auth = Auth()
+        self._auth.token_login(login_token, save_token=True)
+        self._client = self._auth.create_api_client()
+        self._api = ProductLicenseServiceApi(self._client)
+
+    def validate_license(self, license_key: str, product_id: str) -> bool:
+        """Validate a license key for a specific product.
+
+        Args:
+            license_key: The license key to validate
+            product_id: The product ID
+
+        Returns:
+            bool: True if license is valid, False otherwise
+
+        Raises:
+            Exception: If license validation fails
+        """
+        try:
+            response = self._api.product_license_service_validate_license(
+                body=LicenseKeyValidateBody(product_id=product_id), license_key=license_key
+            )
+            return response.is_valid
+        except Exception:
+            raise InvalidLicenseError(f"Invalid license key {license_key} for product {product_id}") from None
+
+
+class InvalidLicenseError(Exception):
+    pass