scientiveshield-tools 0.1.0__py3-none-any.whl

scientiveshield_tools/__init__.py

@@ -0,0 +1,35 @@
+"""Official ScientiveShield exporter for Devolens (Cryptolens) licensing data."""
+
+from .bundle import SCHEMA_VERSION, validate_bundle_data, validate_import_file
+from .cryptolens import (
+    DEFAULT_BASE_URL,
+    CryptolensClient,
+    create_import_file,
+    list_products,
+)
+from .errors import (
+    ConfigurationError,
+    CryptolensError,
+    ScientiveShieldToolsError,
+    ValidationError,
+)
+from .models import ExportResult, Product, ValidationResult
+
+__all__ = [
+    "ConfigurationError",
+    "CryptolensClient",
+    "CryptolensError",
+    "DEFAULT_BASE_URL",
+    "ExportResult",
+    "Product",
+    "SCHEMA_VERSION",
+    "ScientiveShieldToolsError",
+    "ValidationError",
+    "ValidationResult",
+    "create_import_file",
+    "list_products",
+    "validate_bundle_data",
+    "validate_import_file",
+]
+
+__version__ = "0.1.0"

scientiveshield_tools/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

scientiveshield_tools/bundle.py

@@ -0,0 +1,159 @@
+"""Bundle schema helpers and offline validation."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from .errors import ValidationError
+from .models import ValidationResult
+
+SCHEMA_VERSION = 2
+
+
+def normalize_customer_id(value: Any) -> int | None:
+    """Cryptolens uses -1 for "no customer"; normalize it to None."""
+    if value is None:
+        return None
+    try:
+        number = int(value)
+    except (TypeError, ValueError):
+        return None
+    return number if number > 0 else None
+
+
+def normalize_machine_limit(value: Any) -> int:
+    try:
+        number = int(value or 0)
+    except (TypeError, ValueError):
+        number = 0
+    return max(0, number)
+
+
+def load_bundle(path: str | Path) -> dict[str, Any]:
+    try:
+        with open(path, encoding="utf-8") as handle:
+            data = json.load(handle)
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ValidationError(f"Could not read bundle: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ValidationError("The bundle root must be a JSON object.")
+    return data
+
+
+def validate_bundle_data(bundle: dict[str, Any]) -> ValidationResult:
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    schema = int(bundle.get("schemaVersion") or 1)
+    if schema > SCHEMA_VERSION:
+        errors.append(f"Unsupported schema version {schema}; this tool supports up to {SCHEMA_VERSION}.")
+
+    products = bundle.get("products") or []
+    customers = bundle.get("customers") or []
+    templates = bundle.get("templates") or []
+    keys = bundle.get("keys") or []
+    if not isinstance(products, list):
+        errors.append("products must be a list.")
+        products = []
+    if not isinstance(customers, list):
+        errors.append("customers must be a list.")
+        customers = []
+    if not isinstance(templates, list):
+        errors.append("templates must be a list.")
+        templates = []
+    if not isinstance(keys, list):
+        errors.append("keys must be a list.")
+        keys = []
+
+    product_ids = {int(p.get("sourceId", 0)) for p in products if isinstance(p, dict)}
+    if len(product_ids) != len(products):
+        errors.append("Duplicate or missing product source ids.")
+    customer_ids = {int(c.get("sourceId", 0)) for c in customers if isinstance(c, dict)}
+    if len(customer_ids) != len(customers):
+        errors.append("Duplicate or missing customer source ids.")
+    template_ids = {int(t.get("sourceId", 0)) for t in templates if isinstance(t, dict)}
+    if len(template_ids) != len(templates):
+        errors.append("Duplicate or missing template source ids.")
+
+    for product in products:
+        if not isinstance(product, dict) or not str(product.get("name") or "").strip():
+            errors.append("A product has no name.")
+            break
+
+    for template in templates:
+        if not isinstance(template, dict):
+            errors.append("A template is not an object.")
+            continue
+        source_product = template.get("sourceProductId")
+        if source_product not in product_ids:
+            errors.append(f"Template {template.get('sourceId')} references unknown product {source_product}.")
+        if not str(template.get("name") or "").strip():
+            errors.append(f"Template {template.get('sourceId')} has no name.")
+
+    seen_keys: set[tuple[int, str]] = set()
+    activation_count = 0
+    data_object_count = 0
+    for key in keys:
+        if not isinstance(key, dict):
+            errors.append("A license is not an object.")
+            continue
+        source_product = key.get("sourceProductId")
+        normalized = str(key.get("key") or "").strip().upper()
+        if not normalized:
+            errors.append(f"License in product {source_product} has no key string.")
+        elif len(normalized) > 32:
+            errors.append(f"License {normalized} is longer than 32 characters.")
+        elif (source_product, normalized) in seen_keys:
+            errors.append(f"Duplicate license {normalized} in product {source_product}.")
+        seen_keys.add((source_product, normalized))
+        if source_product not in product_ids:
+            errors.append(f"License {normalized} references unknown product {source_product}.")
+        customer_id = normalize_customer_id(key.get("sourceCustomerId"))
+        if customer_id is not None and customer_id not in customer_ids:
+            errors.append(f"License {normalized} references unknown customer {customer_id}.")
+        if int(key.get("maxNoOfMachines") or 0) < 0:
+            warnings.append(f"License {normalized} has a negative machine limit; treating it as unlimited.")
+        activations = key.get("activations") or []
+        if isinstance(activations, list):
+            activation_count += len(activations)
+        data_objects = key.get("dataObjects") or []
+        if isinstance(data_objects, list):
+            data_object_count += len(data_objects)
+
+    counts = {
+        "products": len(products),
+        "customers": len(customers),
+        "templates": len(templates),
+        "keys": len(keys),
+        "activations": activation_count,
+        "dataObjects": data_object_count,
+    }
+    return ValidationResult(ok=not errors, errors=errors, warnings=warnings, counts=counts)
+
+
+def validate_import_file(path: str | Path) -> ValidationResult:
+    return validate_bundle_data(load_bundle(path))
+
+
+def write_bundle(path: str | Path, bundle: dict[str, Any]) -> Path:
+    target = Path(path).expanduser()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    text = json.dumps(bundle, indent=2) + "\n"
+    # The bundle contains customer secrets and license keys. Create it owner-only on POSIX.
+    if os.name == "posix":
+        fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                handle.write(text)
+        except Exception:
+            try:
+                os.close(fd)
+            except OSError:
+                pass
+            raise
+    else:
+        target.write_text(text, encoding="utf-8")
+    return target

scientiveshield_tools/cli.py

@@ -0,0 +1,140 @@
+"""Command line entry point for the exporter."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import sys
+
+from .bundle import validate_import_file
+from .cryptolens import CryptolensClient, list_products
+from .errors import ScientiveShieldToolsError
+
+
+def _token(value: str | None) -> str:
+    token = value or os.environ.get("CRYPTOLENS_TOKEN")
+    if token:
+        return token.strip()
+    if sys.stdin.isatty():
+        return getpass.getpass("Cryptolens read-only access token: ").strip()
+    raise ScientiveShieldToolsError("Pass --token or set CRYPTOLENS_TOKEN.")
+
+
+def _select_products(token: str, base_url: str, free_tier: bool, insecure: bool) -> list[int]:
+    products = list_products(token, base_url=base_url, free_tier=free_tier, insecure=insecure)
+    if not products:
+        raise ScientiveShieldToolsError("No products returned. Check the token permissions.")
+    print("Products:", file=sys.stderr)
+    for index, product in enumerate(products, start=1):
+        print(f"  {index}. {product.name} (id {product.id})", file=sys.stderr)
+    raw = input("Select product numbers (comma-separated): ").strip()
+    indexes = {int(part) for part in raw.split(",") if part.strip().isdigit()}
+    selected = [product.id for index, product in enumerate(products, start=1) if index in indexes]
+    if not selected:
+        raise ScientiveShieldToolsError("No products selected.")
+    return selected
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="scientiveshield-tools",
+        description="Export Devolens/Cryptolens licensing data for ScientiveShield.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    list_parser = sub.add_parser("list-products", help="List products in the account")
+    list_parser.add_argument("--token")
+    list_parser.add_argument("--base-url", default=None)
+    list_parser.add_argument("--free-tier", action="store_true")
+    list_parser.add_argument("--insecure", action="store_true")
+    list_parser.add_argument("--json", action="store_true")
+
+    export_parser = sub.add_parser("export", help="Create a ScientiveShield import bundle")
+    export_parser.add_argument("--token")
+    export_parser.add_argument("--product", action="append", type=int, default=[])
+    export_parser.add_argument("--out", default="bundle.json")
+    export_parser.add_argument("--base-url", default=None)
+    export_parser.add_argument("--interactive", action="store_true")
+    export_parser.add_argument("--free-tier", action="store_true")
+    export_parser.add_argument("--skip-data-objects", action="store_true")
+    export_parser.add_argument("--insecure", action="store_true")
+
+    validate_parser = sub.add_parser("validate", help="Validate a bundle offline")
+    validate_parser.add_argument("--bundle", required=True)
+    validate_parser.add_argument("--json", action="store_true")
+
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "list-products":
+            token = _token(args.token)
+            base_url = args.base_url or "https://api.cryptolens.io/api"
+            products = list_products(
+                token, base_url=base_url, free_tier=args.free_tier, insecure=args.insecure
+            )
+            if args.json:
+                import json
+
+                print(json.dumps([
+                    {"id": p.id, "name": p.name, "keyAlgorithm": p.key_algorithm}
+                    for p in products
+                ], indent=2))
+            else:
+                for product in products:
+                    print(f"{product.id}\t{product.name}\t{product.key_algorithm}")
+            return 0
+
+        if args.command == "export":
+            token = _token(args.token)
+            base_url = args.base_url or "https://api.cryptolens.io/api"
+            product_ids = list(args.product)
+            if not product_ids and args.interactive:
+                product_ids = _select_products(token, base_url, args.free_tier, args.insecure)
+            if not product_ids:
+                raise ScientiveShieldToolsError("Select products with --product or use --interactive.")
+            result = CryptolensClient(
+                token,
+                base_url=base_url,
+                free_tier=args.free_tier,
+                insecure=args.insecure,
+            ).export(
+                product_ids,
+                args.out,
+                include_data_objects=not args.skip_data_objects,
+            )
+            print(result.summary)
+            for warning in result.warnings:
+                print(f"WARNING: {warning}", file=sys.stderr)
+            return 0
+
+        if args.command == "validate":
+            result = validate_import_file(args.bundle)
+            if args.json:
+                import json
+
+                print(json.dumps({
+                    "ok": result.ok,
+                    "errors": result.errors,
+                    "warnings": result.warnings,
+                    "counts": result.counts,
+                }, indent=2))
+            else:
+                for error in result.errors:
+                    print(f"ERROR: {error}", file=sys.stderr)
+                for warning in result.warnings:
+                    print(f"WARNING: {warning}", file=sys.stderr)
+                if result.ok:
+                    print("Bundle OK:", result.counts)
+                else:
+                    return 2
+            return 0 if result.ok else 2
+    except ScientiveShieldToolsError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        return 130
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scientiveshield_tools/cryptolens.py

@@ -0,0 +1,436 @@
+"""Cryptolens/Devolens export client and bundle builder."""
+
+from __future__ import annotations
+
+import json
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Iterable
+
+import requests
+
+from .bundle import (
+    SCHEMA_VERSION,
+    normalize_customer_id,
+    normalize_machine_limit,
+    validate_bundle_data,
+    write_bundle,
+)
+from .errors import ConfigurationError, CryptolensError, ValidationError
+from .models import ExportResult, Product
+
+DEFAULT_BASE_URL = "https://api.cryptolens.io/api"
+USER_AGENT = "scientiveshield-tools/0.1.0"
+
+
+class CryptolensClient:
+    """Small, read-only Cryptolens API client for migration exports."""
+
+    def __init__(
+        self,
+        token: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 90,
+        free_tier: bool = False,
+        min_request_interval: float | None = None,
+        max_retries: int = 8,
+        insecure: bool = False,
+        session: requests.Session | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        if not token or not token.strip():
+            raise ConfigurationError("A Cryptolens read-only access token is required.")
+        self._token = token.strip()
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.free_tier = free_tier
+        self.min_request_interval = max(
+            float(min_request_interval or 0),
+            10.0 if free_tier else 0.0,
+        )
+        self.max_retries = max(1, max_retries)
+        self.insecure = insecure
+        self._session = session or requests.Session()
+        self._session.headers.update({"User-Agent": USER_AGENT})
+        self._sleep = sleep
+        self._clock = clock
+        self._last_request_at: float | None = None
+
+    def __repr__(self) -> str:
+        return f"CryptolensClient(base_url={self.base_url!r}, token=<redacted>)"
+
+    def _wait_for_turn(self) -> None:
+        if self.min_request_interval <= 0 or self._last_request_at is None:
+            return
+        remaining = self.min_request_interval - (self._clock() - self._last_request_at)
+        if remaining > 0:
+            self._sleep(remaining)
+
+    def _retry_delay(self, attempt: int, response: requests.Response | None) -> float:
+        if response is not None:
+            retry_after = response.headers.get("Retry-After")
+            if retry_after:
+                try:
+                    return max(0.0, float(retry_after))
+                except ValueError:
+                    pass
+            if response.status_code == 429:
+                return 10.0 if self.free_tier else min(2.0**attempt, 20.0)
+        return min(2.0**attempt, 20.0)
+
+    def _post(self, method: str, data: dict[str, Any]) -> dict[str, Any]:
+        payload = {"token": self._token, **{k: v for k, v in data.items() if v is not None}}
+        url = f"{self.base_url}/{method}"
+        delay = 1.0
+        for attempt in range(self.max_retries + 1):
+            self._wait_for_turn()
+            self._last_request_at = self._clock()
+            try:
+                response = self._session.post(
+                    url,
+                    data=payload,
+                    timeout=self.timeout,
+                    verify=not self.insecure,
+                )
+            except requests.RequestException as exc:
+                if attempt >= self.max_retries:
+                    raise CryptolensError(f"{method}: could not reach Cryptolens: {exc}") from exc
+                self._sleep(delay)
+                delay = min(delay * 2, 20)
+                continue
+
+            if response.status_code == 429 or response.status_code >= 500:
+                if attempt >= self.max_retries:
+                    raise CryptolensError(
+                        f"{method}: Cryptolens returned HTTP {response.status_code} after retries."
+                    )
+                wait = self._retry_delay(attempt, response)
+                if response.status_code == 429:
+                    # Avoid collecting another 429 on the next call.
+                    self.min_request_interval = max(self.min_request_interval, 10.0)
+                self._sleep(wait)
+                delay = max(delay, wait)
+                continue
+
+            if response.status_code >= 400:
+                raise CryptolensError(f"{method}: Cryptolens returned HTTP {response.status_code}.")
+            try:
+                body = response.json()
+            except ValueError as exc:
+                raise CryptolensError(f"{method}: Cryptolens returned a non-JSON response.") from exc
+            if body.get("result") not in (0, None):
+                raise CryptolensError(f"{method}: {body.get('message') or 'request failed'}")
+            return body
+        raise CryptolensError(f"{method}: retries exhausted")
+
+    def list_products(self) -> list[Product]:
+        body = self._post("product/GetProducts", {})
+        products = body.get("products") or []
+        result: list[Product] = []
+        for item in products:
+            try:
+                product_id = int(item.get("id"))
+            except (TypeError, ValueError):
+                continue
+            result.append(Product(
+                id=product_id,
+                name=str(item.get("name") or f"Product {product_id}"),
+                key_algorithm=key_algorithm(item),
+                is_public=bool(item.get("isPublic", False)),
+                feature_definitions=tuple(product_features(item)),
+            ))
+        return result
+
+    def export(
+        self,
+        product_ids: Iterable[int],
+        output: str | Path = "bundle.json",
+        *,
+        include_data_objects: bool = True,
+    ) -> ExportResult:
+        selected_ids = sorted({int(value) for value in product_ids})
+        if not selected_ids:
+            raise ConfigurationError("Select at least one product id explicitly.")
+
+        all_products = self.list_products()
+        by_id = {product.id: product for product in all_products}
+        missing = [value for value in selected_ids if value not in by_id]
+        if missing:
+            raise ConfigurationError(f"Unknown product ids: {', '.join(map(str, missing))}")
+        selected = [by_id[value] for value in selected_ids]
+
+        products = [
+            {
+                "sourceId": product.id,
+                "name": product.name,
+                "keyAlgorithm": product.key_algorithm,
+                "isPublic": product.is_public,
+                "defaultTrialDays": 15,
+                "featureDefinitions": list(product.feature_definitions),
+            }
+            for product in selected
+        ]
+
+        customers_body = self._post("customer/GetCustomers", {"ModelVersion": 3})
+        customers_raw = customers_body.get("customers") or customers_body.get("Customers") or []
+        customers = [self._customer(item) for item in customers_raw if isinstance(item, dict)]
+
+        templates_body = self._post("licensetemplate/GetLicenseTemplates", {})
+        templates_raw = templates_body.get("licenseTemplates") or templates_body.get("LicenseTemplates") or []
+        templates = [
+            parsed for parsed in (parse_template(item) for item in templates_raw if isinstance(item, dict))
+            if parsed["sourceProductId"] in selected_ids
+        ]
+
+        warnings: list[str] = []
+        keys: list[dict[str, Any]] = []
+        for product in selected:
+            page = 1
+            while True:
+                body = self._post(
+                    "product/GetKeys",
+                    {"ProductId": product.id, "Page": page, "PageSize": 99},
+                )
+                page_keys = body.get("licenseKey") or body.get("licenseKeys") or body.get("keys") or []
+                for raw_key in page_keys:
+                    if isinstance(raw_key, dict):
+                        keys.append(self._key(raw_key, product.id, include_data_objects, warnings))
+                returned = int(body.get("returned") or len(page_keys))
+                page_count = int(body.get("pageCount") or 0)
+                if (page_count and page >= page_count) or returned < 99:
+                    break
+                page += 1
+
+        bundle = {
+            "schemaVersion": SCHEMA_VERSION,
+            "source": "cryptolens",
+            "exportedAt": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "products": products,
+            "customers": customers,
+            "templates": templates,
+            "keys": keys,
+            "warnings": warnings,
+        }
+        bundle["counts"] = {
+            "products": len(products),
+            "customers": len(customers),
+            "templates": len(templates),
+            "keys": len(keys),
+            "activations": sum(len(k["activations"]) for k in keys),
+            "dataObjects": sum(len(k["dataObjects"]) for k in keys),
+        }
+
+        validation = validate_bundle_data(bundle)
+        if validation.errors:
+            raise ValidationError("; ".join(validation.errors))
+        warnings.extend(w for w in validation.warnings if w not in warnings)
+        bundle["warnings"] = warnings
+
+        target = write_bundle(output, bundle)
+        return ExportResult(
+            path=target,
+            products=len(products),
+            customers=len(customers),
+            templates=len(templates),
+            keys=len(keys),
+            activations=bundle["counts"]["activations"],
+            data_objects=bundle["counts"]["dataObjects"],
+            warnings=warnings,
+            bytes_written=target.stat().st_size,
+        )
+
+    def _key(
+        self,
+        raw: dict[str, Any],
+        product_id: int,
+        include_data_objects: bool,
+        warnings: list[str],
+    ) -> dict[str, Any]:
+        key = str(raw.get("key") or "").strip()
+        original_max = raw.get("maxNoOfMachines")
+        max_machines = normalize_machine_limit(original_max)
+        if original_max is not None and int(original_max or 0) < 0:
+            warnings.append(f"License {key} has a negative machine limit; treating it as unlimited.")
+
+        data_objects: list[dict[str, Any]] = []
+        if include_data_objects:
+            for obj in raw.get("dataObjects") or []:
+                if isinstance(obj, dict):
+                    _add_data_object(data_objects, obj, "")
+            try:
+                body = self._post(
+                    "data/ListDataObjectsToKey",
+                    {"ProductId": product_id, "Key": key},
+                )
+                for obj in body.get("dataObjects") or []:
+                    if isinstance(obj, dict):
+                        _add_data_object(data_objects, obj, "")
+            except CryptolensError as exc:
+                warnings.append(f"Data objects for {key}: {exc}")
+
+        activations = [
+            {
+                "machineCode": str(item.get("mid") or ""),
+                "friendlyName": str(item.get("friendlyName") or ""),
+                "ip": str(item.get("ip") or ""),
+                "time": item.get("time"),
+                "floatingExpires": item.get("floatingExpires"),
+            }
+            for item in (raw.get("activatedMachines") or [])
+            if isinstance(item, dict)
+        ]
+
+        if include_data_objects:
+            for activation in activations:
+                machine = activation["machineCode"].strip()
+                if not machine:
+                    continue
+                try:
+                    body = self._post(
+                        "data/ListDataObjectsToMachineCode",
+                        {"ProductId": product_id, "Key": key, "MachineCode": machine},
+                    )
+                    for obj in body.get("dataObjects") or []:
+                        if isinstance(obj, dict):
+                            _add_data_object(data_objects, obj, machine)
+                except CryptolensError as exc:
+                    warnings.append(f"Machine data objects for {key} / {machine}: {exc}")
+
+        return {
+            "sourceProductId": product_id,
+            "key": key,
+            "sourceId": raw.get("id"),
+            "sourceGlobalId": raw.get("globalId"),
+            "created": raw.get("created"),
+            "expires": raw.get("expires"),
+            "period": int(raw.get("period") or 0),
+            "f1": bool(raw.get("f1", False)),
+            "f2": bool(raw.get("f2", False)),
+            "f3": bool(raw.get("f3", False)),
+            "f4": bool(raw.get("f4", False)),
+            "f5": bool(raw.get("f5", False)),
+            "f6": bool(raw.get("f6", False)),
+            "f7": bool(raw.get("f7", False)),
+            "f8": bool(raw.get("f8", False)),
+            "notes": str(raw.get("notes") or ""),
+            "block": bool(raw.get("block", False)),
+            "maxNoOfMachines": max_machines,
+            "allowedMachines": str(raw.get("allowedMachines") or ""),
+            "trialActivation": bool(raw.get("trialActivation", False)),
+            "sourceCustomerId": normalize_customer_id((raw.get("customer") or {}).get("id")),
+            "activations": activations,
+            "dataObjects": data_objects,
+        }
+
+    @staticmethod
+    def _customer(raw: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "sourceId": raw.get("id"),
+            "name": str(raw.get("name") or ""),
+            "email": str(raw.get("email") or ""),
+            "companyName": str(raw.get("companyName") or ""),
+            "secret": str(raw.get("secret") or ""),
+        }
+
+def _add_data_object(target: list[dict[str, Any]], raw: dict[str, Any], machine: str) -> None:
+    name = str(raw.get("name") or "").strip()
+    if not name:
+        return
+    machine_code = machine or str(raw.get("machineCode") or "").strip()
+    if any(item["name"] == name and item["machineCode"] == machine_code for item in target):
+        return
+    target.append({
+        "name": name,
+        "stringValue": str(raw.get("stringValue") or ""),
+        "intValue": int(raw.get("intValue") or 0),
+        "machineCode": machine_code,
+    })
+
+
+def parse_template(template: dict[str, Any]) -> dict[str, Any]:
+    params = template.get("parameters")
+    if isinstance(params, str):
+        try:
+            params = json.loads(params)
+        except json.JSONDecodeError:
+            params = {}
+    if isinstance(params, list):
+        params = next(
+            (item.get("Parameters", {}) for item in params if item.get("APIMethodName") == "CreateKey"),
+            {},
+        )
+    if not isinstance(params, dict):
+        params = {}
+
+    def value(name: str, default: Any = None) -> Any:
+        return params.get(name, params.get(name[:1].upper() + name[1:], default))
+
+    return {
+        "sourceId": template.get("id"),
+        "sourceProductId": template.get("productId") or value("ProductId"),
+        "name": template.get("name") or f"Template {template.get('id')}",
+        "period": int(value("Period", 30) or 30),
+        "f1": bool(value("F1", False)),
+        "f2": bool(value("F2", False)),
+        "f3": bool(value("F3", False)),
+        "f4": bool(value("F4", False)),
+        "f5": bool(value("F5", False)),
+        "f6": bool(value("F6", False)),
+        "f7": bool(value("F7", False)),
+        "f8": bool(value("F8", False)),
+        "maxNoOfMachines": int(value("MaxNoOfMachines", 0) or 0),
+        "trialActivation": bool(value("TrialActivation", False)),
+        "block": bool(value("Block", False)),
+        "notes": value("Notes") or "",
+    }
+
+
+def key_algorithm(product: dict[str, Any]) -> str:
+    return "Skgl" if product.get("keyAlgorithm") == 0 else "Skm15"
+
+
+def product_features(product: dict[str, Any]) -> list[dict[str, str]]:
+    definitions = product.get("featureDefinitions") or {}
+    result: list[dict[str, str]] = []
+    for index in range(1, 9):
+        item = definitions.get(f"f{index}") or {}
+        name = item.get("name")
+        if name:
+            result.append({"key": f"F{index}", "name": str(name)})
+    return result
+
+
+def list_products(
+    token: str,
+    *,
+    base_url: str = DEFAULT_BASE_URL,
+    free_tier: bool = False,
+    insecure: bool = False,
+) -> list[Product]:
+    return CryptolensClient(
+        token,
+        base_url=base_url,
+        free_tier=free_tier,
+        insecure=insecure,
+    ).list_products()
+
+
+def create_import_file(
+    token: str,
+    product_ids: Iterable[int],
+    output: str | Path = "bundle.json",
+    *,
+    base_url: str = DEFAULT_BASE_URL,
+    free_tier: bool = False,
+    include_data_objects: bool = True,
+    insecure: bool = False,
+) -> ExportResult:
+    return CryptolensClient(
+        token,
+        base_url=base_url,
+        free_tier=free_tier,
+        insecure=insecure,
+    ).export(product_ids, output, include_data_objects=include_data_objects)

scientiveshield_tools/errors.py

@@ -0,0 +1,17 @@
+"""Package exceptions."""
+
+
+class ScientiveShieldToolsError(Exception):
+    """Base exception for the exporter."""
+
+
+class ConfigurationError(ScientiveShieldToolsError):
+    """Invalid local configuration or arguments."""
+
+
+class CryptolensError(ScientiveShieldToolsError):
+    """Cryptolens rejected a request or could not be reached."""
+
+
+class ValidationError(ScientiveShieldToolsError):
+    """An import bundle is not valid."""

scientiveshield_tools/models.py

@@ -0,0 +1,57 @@
+"""Public result and product models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Product:
+    id: int
+    name: str
+    key_algorithm: str = "Skm15"
+    is_public: bool = False
+    feature_definitions: tuple[dict[str, str], ...] = field(default_factory=tuple)
+
+
+@dataclass
+class ExportResult:
+    path: Path
+    products: int = 0
+    customers: int = 0
+    templates: int = 0
+    keys: int = 0
+    activations: int = 0
+    data_objects: int = 0
+    warnings: list[str] = field(default_factory=list)
+    bytes_written: int = 0
+
+    @property
+    def summary(self) -> str:
+        return (
+            f"Wrote {self.path}: {self.products} products, {self.customers} customers, "
+            f"{self.templates} templates, {self.keys} keys, {self.activations} activations, "
+            f"{self.data_objects} data objects."
+        )
+
+
+@dataclass
+class ValidationResult:
+    ok: bool
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    counts: dict[str, int] = field(default_factory=dict)
+
+    def raise_for_errors(self) -> None:
+        if self.errors:
+            from .errors import ValidationError
+
+            raise ValidationError("; ".join(self.errors))
+
+
+@dataclass
+class ExportBundle:
+    data: dict[str, Any]
+    summary: ExportResult

scientiveshield_tools-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: scientiveshield-tools
+Version: 0.1.0
+Summary: Export Devolens (Cryptolens) licensing data into a ScientiveShield import bundle.
+Author: ScientiveShield
+License-Expression: BUSL-1.1
+Project-URL: Homepage, https://scientiveshield.pro/migrate/developer/
+Project-URL: Documentation, https://scientiveshield.pro/migrate/developer/
+Project-URL: Repository, https://github.com/franciscomvargas/scientiveshield-tools
+Project-URL: Issues, https://github.com/franciscomvargas/scientiveshield-tools/issues
+Keywords: licensing,cryptolens,devolens,migration,scientiveshield
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Dynamic: license-file
+
+# scientiveshield-tools
+
+Export Devolens (formerly Cryptolens) products, customers, templates, licenses, activations and
+data objects into one ScientiveShield import bundle.
+
+This package is the official ScientiveShield exporter. It is **not** a Cryptolens SDK.
+
+## Install
+
+```bash
+python -m pip install --upgrade scientiveshield-tools
+```
+
+Python 3.10+ is required.
+
+## Create an import file
+
+Use a read-only Devolens/Cryptolens token with these permissions:
+
+- Get Products
+- Get Keys
+- Get Customers
+- License Template
+- List Data Objects
+
+```python
+from scientiveshield_tools import create_import_file
+
+result = create_import_file(
+    token="read-only-cryptolens-token",
+    product_ids=[33453, 33454],
+    output="bundle.json",
+)
+
+print(result.summary)
+```
+
+The exporter writes schema version 2 and preserves key strings. It includes key-scoped and
+machine-scoped data objects. Product selection is explicit; it never exports every product by
+accident.
+
+### Inspect products
+
+```python
+from scientiveshield_tools import list_products
+
+for product in list_products(token="..."):
+    print(product.id, product.name)
+```
+
+### Validate the file
+
+```python
+from scientiveshield_tools import validate_import_file
+
+result = validate_import_file("bundle.json")
+print(result.ok, result.errors, result.warnings)
+```
+
+### Free environment
+
+Cryptolens’ limited free environment allows one API request every 10 seconds. Use:
+
+```python
+create_import_file(..., free_tier=True)
+```
+
+The client then spaces requests proactively. On a 429 response it honors `Retry-After`, otherwise
+waits 10 seconds. A free-tier export can take a few minutes; that is expected.
+
+## CLI (optional)
+
+```bash
+python -m scientiveshield_tools list-products --token "$CRYPTOLENS_TOKEN"
+python -m scientiveshield_tools export --interactive --out bundle.json
+python -m scientiveshield_tools validate --bundle bundle.json
+```
+
+## Security
+
+- Use a **read-only** token. Never use the Cryptolens account password.
+- The token is never logged or included in the bundle.
+- The bundle contains customer secrets and license data. Share it only via a secure channel.
+- Revoke the source token after the export.
+- Do not commit `bundle.json` or tokens.
+
+## Import and cutover
+
+Upload the bundle in ScientiveShield → **Migration**. The dashboard validates it, shows a dry-run
+preview, imports through a background worker, and provides the app cutover kit.
+
+Developer guide: <https://scientiveshield.pro/migrate/developer/>
+
+## License
+
+Business Source License 1.1 with an Additional Use Grant. See [LICENSE](LICENSE). Commercial use is
+permitted for migrating your own or your clients’ software into ScientiveShield. The Licensed Work
+may not be offered as a standalone commercial product, managed service, or competing licensing
+platform. The Change Date is 2030-10-21; the Change License is Apache-2.0.

scientiveshield_tools-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+scientiveshield_tools/__init__.py,sha256=z2uH2XqkjGscbg9ICwrdwENPoiB_UU8ajA57bNGIhoM,833
+scientiveshield_tools/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+scientiveshield_tools/bundle.py,sha256=7aXVpCfgP2t0DRgquz6iIbbUxYoT1zX0hZTN1hlLtuM,6130
+scientiveshield_tools/cli.py,sha256=BvM5fxIVELmeZPjBq0MZ4W0V_-rSYDplzAivDf6C0rw,5676
+scientiveshield_tools/cryptolens.py,sha256=78_ilakhTI0LnBdSADCLw4OXSvkMO5KBSiuHJZaoPeo,16812
+scientiveshield_tools/errors.py,sha256=OteAFDOLZt4NKB9pJ4hf2aLpH3NmcBl0m0eWf6gLqGs,432
+scientiveshield_tools/models.py,sha256=tk8N7lnyAfUUoR-yjF4gUCs0U1G71ghHJituP8GpXBU,1416
+scientiveshield_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scientiveshield_tools-0.1.0.dist-info/licenses/LICENSE,sha256=7FD0ka9GSHKOmn0GsZsexsbo66K2eNXpNackhuWdtcs,4164
+scientiveshield_tools-0.1.0.dist-info/METADATA,sha256=S9WwWi5ktzVZZuaatbTizk_eN348CkaAACTEe0ABc0E,4054
+scientiveshield_tools-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+scientiveshield_tools-0.1.0.dist-info/entry_points.txt,sha256=Ep0-lYsA6oAEt-zN3dyXlaiiwglZLLAe1og-gCIMaDY,73
+scientiveshield_tools-0.1.0.dist-info/top_level.txt,sha256=GB6YKrYWc-1qmZ-8jCH38VnALvsXywegVbJEoSlFjQg,22
+scientiveshield_tools-0.1.0.dist-info/RECORD,,

scientiveshield_tools-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

scientiveshield_tools-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scientiveshield-tools = scientiveshield_tools.cli:main

scientiveshield_tools-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,88 @@
+Business Source License 1.1
+
+License text copyright © 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license
+your works, and to refer to it using the trademark “Business Source License”,
+as long as you comply with the Covenants of Licensor below.
+
+Covenants of Licensor
+
+In consideration of the right to use this License’s text and the “Business
+Source License” name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where “compatible” means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text “None”.
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+
+---
+
+License parameters
+
+Licensor: ScientiveShield
+Licensed Work: scientiveshield-tools, version 0.1.0 and later versions
+Additional Use Grant: You may use, reproduce, and distribute the Licensed Work,
+including in production, solely to export data from Devolens/Cryptolens for
+import into ScientiveShield. This includes use by the licensed customer's
+employees, contractors, agencies, and other authorized service providers
+acting on the customer's behalf, and internal evaluation, testing, and CI use.
+You may not offer the Licensed Work, or a derivative work, as a standalone
+commercial product, managed service, or as part of a competing software
+licensing platform.
+Change Date: 2030-10-21
+Change License: Apache License, Version 2.0

scientiveshield_tools-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+scientiveshield_tools