Python SDK

pip install quantumlock          # add [pqc] for local ML-DSA verification

from quantumlock.sdk import QuantumLockClient

client = QuantumLockClient(
    api_key="YOUR_PLATFORM_API_KEY",
    api_url="https://quantumlock.softquantus.com",  # default
    timeout=30,
)

# Licenses
lic = client.generate_license(
    end_customer_id="user@company.com",
    features=["premium"],
    valid_days=365,
)
result = client.validate_license(
    license_key=lic["license_key"],
    end_customer_id="user@company.com",
)
client.revoke_license(lic["license_key"])          # needs quantumlock:keys

# Account
me = client.get_customer_info()
stats = client.get_stats()

# v2 artifacts
client.v2_revoke_license(license_id="jti-...", reason="chargeback")
proof = client.v2_status_proof(license_id="jti-...")

# Enterprise Key Engine
job = client.entropy_collect(source="local", bits=65536)
key = client.enterprise_keygen(algorithm="ml-dsa-65", name="release-signing")
client.enterprise_key_rotate(key["key"]["id"], reason="scheduled")
report = client.key_provenance_report()

# Artifact signing (.qsig)
bundle = client.artifact_sign(artifact=open("app.tar.gz", "rb").read(),
                              artifact_name="app.tar.gz")
check = client.artifact_verify(artifact=open("app.tar.gz", "rb").read(),
                               signature=bundle["signature"])

# Diagnostics
print(client.doctor())
print(client.quantum_health())

from quantumlock.sdk import LicenseValidator, LicenseError, FeatureNotLicensed

validator = LicenseValidator()
try:
    if validator.validate("/etc/myapp/license.lic"):
        print(validator.get_license_info())
except LicenseError as e:
    print(f"License problem: {e}")

@validator.require_feature("analytics")
def analytics_endpoint():
    return {"data": "..."}

from pathlib import Path
from quantumlock.core.artifacts import LicenseArtifact
from quantumlock.core.pqc import KeyRegistry
from quantumlock.sdk import LicenseValidatorV2

validator = LicenseValidatorV2(
    key_registry=KeyRegistry(),                     # public keys for verification
    revocation_url="https://quantumlock.softquantus.com/api/v1/v2/revocation",
    anti_rollback_path=Path("~/.myapp/epoch").expanduser(),
    require_pqc=False,
    allow_grace_period=True,
)

artifact = LicenseArtifact.from_json(Path("license.json").read_text())
result = validator.validate(artifact, device_fingerprint={"machine_id": "5f2a..."})

if result.is_valid:
    print(result.status, result.entitlements, result.expires_at)
    if result.in_grace_period:
        warn_user(until=result.grace_until)
else:
    print(result.error, result.error_message)   # e.g. revoked, epoch_rollback, binding_mismatch

validator.cache_proof(proof)                        # from POST /api/v1/v2/status-proof
result = validator.validate_offline(artifact)       # proof cache first, then local checks

from quantumlock.sdk import validate_license

result = validate_license(
    license_json=Path("license.json").read_text(),
    key_pem=Path("license_signing.pub").read_text(),
)

from quantumlock.sdk.hybrid_validator import HybridLicenseValidator, HybridConfig

validator = HybridLicenseValidator(
    config=HybridConfig(
        license_path="/etc/myapp/license.qlicense",
        mode="hybrid",              # offline | online | hybrid
        sync_interval_hours=24,
        grace_period_days=7,
    )
)

result = validator.validate()
if not result.is_valid:
    raise SystemExit(result.message)

validator.on_revoked(lambda r: shutdown_features())
validator.on_grace_period(lambda r: warn_user(r.grace_period_ends))

if validator.has_feature("premium"):
    enable_premium()

# Feature gating decorator
@validator.require_license(features=["premium"])
def premium_feature():
    ...

# Force a synchronous online check (e.g. before a critical operation)
fresh = validator.force_online_check()