digitea-licensing 1.1.1__tar.gz

digitea_licensing-1.1.1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: digitea-licensing
+Version: 1.1.1
+Summary: Digitea Runtime licensing client
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: urllib3<3,>=2

digitea_licensing-1.1.1/README.md

@@ -0,0 +1,11 @@
+# Digitea Licensing Python SDK
+
+The public facade is DigiteaLicensing. The generated OpenAPI transport under generated/ is an implementation detail.
+
+Example:
+
+    from digitea_licensing import DigiteaLicensing
+    client = DigiteaLicensing(product_id="prd_example123")
+    result = client.activate("dgt_lic_example", instance_id="stable-id")
+
+The renewal method generates an idempotency key. Pass the same idempotency_key when retrying a logical operation.

digitea_licensing-1.1.1/digitea_licensing/__init__.py

@@ -0,0 +1,5 @@
+from .client import DigiteaLicensing
+from .errors import DigiteaError
+from .storage import FileInstanceIdStore, InstanceIdStore
+
+__all__ = ["DigiteaLicensing", "DigiteaError", "FileInstanceIdStore", "InstanceIdStore"]

digitea_licensing-1.1.1/digitea_licensing/client.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import re
+import secrets
+import time
+import sys
+from pathlib import Path
+from typing import Any
+
+_generated_root = str(Path(__file__).resolve().parents[1] / "generated")
+if _generated_root not in sys.path:
+    sys.path.insert(0, _generated_root)
+
+from digitea_licensing_generated.api.runtime_api import RuntimeApi
+from digitea_licensing_generated.api_client import ApiClient
+from digitea_licensing_generated.configuration import Configuration
+from digitea_licensing_generated.models.activate_input import ActivateInput
+from digitea_licensing_generated.models.runtime_input import RuntimeInput
+
+from .errors import from_exception
+from .storage import FileInstanceIdStore, InstanceIdStore, get_or_create
+
+_KEY_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]*$")
+_RETRYABLE = {408, 429, 500, 502, 503, 504}
+
+
+class DigiteaLicensing:
+    def __init__(
+        self,
+        product_id: str,
+        base_url: str = "https://api.getdigitea.com",
+        *,
+        instance_id: str | None = None,
+        instance_store: InstanceIdStore | None = None,
+        timeout: float = 10.0,
+        retries: int = 2,
+        api: Any | None = None,
+    ):
+        if not product_id:
+            raise ValueError("product_id is required")
+        if timeout <= 0 or retries < 0:
+            raise ValueError("timeout must be positive and retries must be non-negative")
+        self.product_id = product_id
+        self.timeout = timeout
+        self.retries = retries
+        self.instance_store = instance_store or FileInstanceIdStore()
+        self.instance_id = instance_id or get_or_create(self.instance_store)
+        if api is None:
+            configuration = Configuration(host=base_url.rstrip("/"))
+            api = RuntimeApi(ApiClient(configuration))
+        self._api = api
+
+    def activate(self, license_key: str, *, instance_id: str | None = None, instance_name: str | None = None):
+        payload = ActivateInput(
+            license_key=license_key,
+            product_id=self.product_id,
+            instance_id=instance_id or self.instance_id,
+            instance_name=instance_name,
+        )
+        return self._call(lambda: self._api.activate_license(payload, _request_timeout=self.timeout))
+
+    def validate(self, license_key: str, *, instance_id: str | None = None):
+        payload = self._runtime_input(license_key, instance_id)
+        return self._call(lambda: self._api.validate_license(payload, _request_timeout=self.timeout))
+
+    def deactivate(self, license_key: str, *, instance_id: str | None = None):
+        payload = self._runtime_input(license_key, instance_id)
+        return self._call(lambda: self._api.deactivate_license(payload, _request_timeout=self.timeout))
+
+    def create_renewal_session(
+        self,
+        license_key: str,
+        *,
+        instance_id: str | None = None,
+        idempotency_key: str | None = None,
+    ):
+        key = idempotency_key or ("rnl_" + secrets.token_urlsafe(24))
+        if not _KEY_RE.fullmatch(key) or not 8 <= len(key) <= 128:
+            raise ValueError("idempotency_key must match the Digitea contract")
+        payload = self._runtime_input(license_key, instance_id)
+        return self._call(lambda: self._api.create_renewal_session(
+            payload, _request_timeout=self.timeout, _headers={"Idempotency-Key": key}
+        ))
+
+    def _runtime_input(self, license_key: str, instance_id: str | None):
+        return RuntimeInput(
+            license_key=license_key,
+            product_id=self.product_id,
+            instance_id=instance_id or self.instance_id,
+        )
+
+    def _call(self, operation):
+        for attempt in range(self.retries + 1):
+            try:
+                return operation()
+            except Exception as raw:
+                error = from_exception(raw)
+                if attempt >= self.retries or (error.status is not None and error.status not in _RETRYABLE):
+                    raise error from raw
+                time.sleep(min(2.0, 0.2 * (2 ** attempt)))
+        raise AssertionError("unreachable")

digitea_licensing-1.1.1/digitea_licensing/errors.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+class DigiteaError(RuntimeError):
+    def __init__(self, code: str, message: str, status: int | None = None, details: Any = None):
+        super().__init__(message)
+        self.code = code
+        self.status = status
+        self.details = details
+
+
+def from_exception(exc: Exception) -> DigiteaError:
+    status = getattr(exc, "status", None) or getattr(exc, "code", None)
+    body = getattr(exc, "body", None)
+    payload = None
+    if isinstance(body, (bytes, bytearray)):
+        body = body.decode("utf-8", "replace")
+    if isinstance(body, str):
+        try:
+            payload = json.loads(body)
+        except json.JSONDecodeError:
+            payload = None
+    if isinstance(payload, dict):
+        error = payload.get("error") if isinstance(payload.get("error"), dict) else payload
+        code = str(error.get("code") or "API_ERROR")
+        message = str(error.get("message") or "Digitea licensing request failed")
+        return DigiteaError(code, message, int(status) if status else None, error.get("details"))
+    code = "NETWORK_ERROR" if not status else "API_ERROR"
+    return DigiteaError(code, str(exc) or "Digitea licensing request failed", int(status) if status else None)

digitea_licensing-1.1.1/digitea_licensing/storage.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import secrets
+from pathlib import Path
+from typing import Protocol
+
+
+class InstanceIdStore(Protocol):
+    def load(self) -> str | None: ...
+    def save(self, instance_id: str) -> None: ...
+
+
+class FileInstanceIdStore:
+    def __init__(self, path: str | os.PathLike[str] | None = None):
+        default = Path.home() / ".digitea" / "instance-id"
+        self.path = Path(path or os.environ.get("DIGITEA_INSTANCE_FILE", default))
+
+    def load(self) -> str | None:
+        try:
+            value = self.path.read_text(encoding="utf-8").strip()
+        except FileNotFoundError:
+            return None
+        return value or None
+
+    def save(self, instance_id: str) -> None:
+        self.path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        temporary = self.path.with_suffix(".tmp")
+        temporary.write_text(instance_id + "\n", encoding="utf-8")
+        try:
+            os.chmod(temporary, 0o600)
+        except OSError:
+            pass
+        os.replace(temporary, self.path)
+
+
+def new_instance_id() -> str:
+    return "inst_" + secrets.token_urlsafe(24)
+
+
+def get_or_create(store: InstanceIdStore) -> str:
+    existing = store.load()
+    if existing:
+        return existing
+    value = new_instance_id()
+    store.save(value)
+    return value

digitea_licensing-1.1.1/digitea_licensing.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: digitea-licensing
+Version: 1.1.1
+Summary: Digitea Runtime licensing client
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: urllib3<3,>=2

digitea_licensing-1.1.1/digitea_licensing.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+README.md
+pyproject.toml
+digitea_licensing/__init__.py
+digitea_licensing/client.py
+digitea_licensing/errors.py
+digitea_licensing/storage.py
+digitea_licensing.egg-info/PKG-INFO
+digitea_licensing.egg-info/SOURCES.txt
+digitea_licensing.egg-info/dependency_links.txt
+digitea_licensing.egg-info/requires.txt
+digitea_licensing.egg-info/top_level.txt
+generated/digitea_licensing_generated/__init__.py
+generated/digitea_licensing_generated/api_client.py
+generated/digitea_licensing_generated/api_response.py
+generated/digitea_licensing_generated/configuration.py
+generated/digitea_licensing_generated/exceptions.py
+generated/digitea_licensing_generated/rest.py
+generated/digitea_licensing_generated/api/__init__.py
+generated/digitea_licensing_generated/api/runtime_api.py
+generated/digitea_licensing_generated/models/__init__.py
+generated/digitea_licensing_generated/models/activate_input.py
+generated/digitea_licensing_generated/models/activation_result.py
+generated/digitea_licensing_generated/models/activation_result_activation.py
+generated/digitea_licensing_generated/models/deactivation_result.py
+generated/digitea_licensing_generated/models/error.py
+generated/digitea_licensing_generated/models/error_error.py
+generated/digitea_licensing_generated/models/licensing_error_code.py
+generated/digitea_licensing_generated/models/renewal_session_result.py
+generated/digitea_licensing_generated/models/runtime_input.py
+generated/digitea_licensing_generated/models/validation_result.py

digitea_licensing-1.1.1/digitea_licensing.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

digitea_licensing-1.1.1/digitea_licensing.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pydantic<3,>=2
+urllib3<3,>=2

digitea_licensing-1.1.1/digitea_licensing.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+digitea_licensing
+digitea_licensing_generated

digitea_licensing-1.1.1/generated/digitea_licensing_generated/__init__.py

@@ -0,0 +1,68 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+    Digitea Licensing Runtime API
+
+    Public Runtime v1 contract. Distributed software uses productId, licenseKey and instanceId. No vendor credential is accepted or required.
+
+    The version of the OpenAPI document: 1.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+__version__ = "0.1.0"
+
+# Define package exports
+__all__ = [
+    "RuntimeApi",
+    "ApiResponse",
+    "ApiClient",
+    "Configuration",
+    "OpenApiException",
+    "ApiTypeError",
+    "ApiValueError",
+    "ApiKeyError",
+    "ApiAttributeError",
+    "ApiException",
+    "ActivateInput",
+    "ActivationResult",
+    "ActivationResultActivation",
+    "DeactivationResult",
+    "Error",
+    "ErrorError",
+    "LicensingErrorCode",
+    "RenewalSessionResult",
+    "RuntimeInput",
+    "ValidationResult",
+]
+
+# import apis into sdk package
+from digitea_licensing_generated.api.runtime_api import RuntimeApi as RuntimeApi
+
+# import ApiClient
+from digitea_licensing_generated.api_response import ApiResponse as ApiResponse
+from digitea_licensing_generated.api_client import ApiClient as ApiClient
+from digitea_licensing_generated.configuration import Configuration as Configuration
+from digitea_licensing_generated.exceptions import OpenApiException as OpenApiException
+from digitea_licensing_generated.exceptions import ApiTypeError as ApiTypeError
+from digitea_licensing_generated.exceptions import ApiValueError as ApiValueError
+from digitea_licensing_generated.exceptions import ApiKeyError as ApiKeyError
+from digitea_licensing_generated.exceptions import ApiAttributeError as ApiAttributeError
+from digitea_licensing_generated.exceptions import ApiException as ApiException
+
+# import models into sdk package
+from digitea_licensing_generated.models.activate_input import ActivateInput as ActivateInput
+from digitea_licensing_generated.models.activation_result import ActivationResult as ActivationResult
+from digitea_licensing_generated.models.activation_result_activation import ActivationResultActivation as ActivationResultActivation
+from digitea_licensing_generated.models.deactivation_result import DeactivationResult as DeactivationResult
+from digitea_licensing_generated.models.error import Error as Error
+from digitea_licensing_generated.models.error_error import ErrorError as ErrorError
+from digitea_licensing_generated.models.licensing_error_code import LicensingErrorCode as LicensingErrorCode
+from digitea_licensing_generated.models.renewal_session_result import RenewalSessionResult as RenewalSessionResult
+from digitea_licensing_generated.models.runtime_input import RuntimeInput as RuntimeInput
+from digitea_licensing_generated.models.validation_result import ValidationResult as ValidationResult
+

digitea_licensing-1.1.1/generated/digitea_licensing_generated/api/__init__.py

@@ -0,0 +1,5 @@
+# flake8: noqa
+
+# import apis into api package
+from digitea_licensing_generated.api.runtime_api import RuntimeApi
+