keymint 2.3.1__tar.gz → 2.5.0__tar.gz

{keymint-2.3.1/keymint.egg-info → keymint-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keymint
-Version: 2.3.1
+Version: 2.5.0
 Summary: License key validation, activation, and management for Python. Supports node-locking, offline licensing, and hardware fingerprinting.
 Home-page: https://github.com/keymint-dev/keymint-python
 Author: KeyMint
@@ -16,18 +16,14 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Software Distribution
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.25.0
+Requires-Dist: requests>=2.32.4
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -107,8 +103,10 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `activate_key`   | Activates a license key for a device.           |
 | `deactivate_key` | Deactivates a device from a license key.        |
 | `get_key`        | Retrieves detailed information about a key.     |
+| `update_key`     | Updates an existing license key.                |
 | `block_key`      | Blocks a license key.                           |
 | `unblock_key`    | Unblocks a previously blocked license key.      |
+| `sign_key`       | Signs a key for offline validation using an admin API key.|
 | `floating_checkout` | Checks out a floating license seat.          |
 | `floating_heartbeat`| Sends a heartbeat to keep a session alive.   |
 | `floating_checkin`  | Checks in a session, releasing the seat.     |

{keymint-2.3.1 → keymint-2.5.0}/README.md

@@ -58,8 +58,10 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `activate_key`   | Activates a license key for a device.           |
 | `deactivate_key` | Deactivates a device from a license key.        |
 | `get_key`        | Retrieves detailed information about a key.     |
+| `update_key`     | Updates an existing license key.                |
 | `block_key`      | Blocks a license key.                           |
 | `unblock_key`    | Unblocks a previously blocked license key.      |
+| `sign_key`       | Signs a key for offline validation using an admin API key.|
 | `floating_checkout` | Checks out a floating license seat.          |
 | `floating_heartbeat`| Sends a heartbeat to keep a session alive.   |
 | `floating_checkin`  | Checks in a session, releasing the seat.     |

{keymint-2.3.1 → keymint-2.5.0}/keymint/__init__.py

@@ -1,6 +1,7 @@
 import requests
-from .types import *
+
 from ._version import __version__
+from .types import *
 
 __all__ = ['KeyMint', 'KeyMintApiError', '__version__']
 
@@ -16,19 +17,23 @@ class KeyMint:
             'Content-Type': 'application/json'
         }
 
-    def _handle_request(self, method: str, endpoint: str, params: dict = None, query_params: dict = None, idempotency_key: str = None):
+    def _handle_request(self, method: str, endpoint: str, params: dict | None = None, query_params: dict | None = None, idempotency_key: str | None = None, extra_headers: dict | None = None):
         url = f'{self.base_url}{endpoint}'
         headers = self.headers.copy()
         if idempotency_key:
             headers['Idempotency-Key'] = idempotency_key
+        if extra_headers:
+            headers.update(extra_headers)
             
         try:
             if method.upper() == 'GET':
                 response = requests.get(url, params=query_params, headers=headers)
             elif method.upper() == 'POST':
-                response = requests.post(url, json=params, headers=headers)
+                response = requests.post(url, json=params, params=query_params, headers=headers)
             elif method.upper() == 'PUT':
-                response = requests.put(url, json=params, headers=headers)
+                response = requests.put(url, json=params, params=query_params, headers=headers)
+            elif method.upper() == 'PATCH':
+                response = requests.patch(url, json=params, params=query_params, headers=headers)
             elif method.upper() == 'DELETE':
                 response = requests.delete(url, params=query_params, headers=headers)
             else:
@@ -39,8 +44,9 @@ class KeyMint:
         except requests.exceptions.HTTPError as http_err:
             try:
                 error_data = http_err.response.json()
+                nested_error = error_data.get('error') if isinstance(error_data.get('error'), dict) else {}
                 raise KeyMintApiError(
-                    message=error_data.get('message', 'An API error occurred'),
+                    message=error_data.get('message') or nested_error.get('message') or 'An API error occurred',
                     code=error_data.get('code', -1),
                     status=http_err.response.status_code
                 )
@@ -53,7 +59,7 @@ class KeyMint:
         except Exception as err:
             raise KeyMintApiError(message=str(err), code=-1)
 
-    def create_key(self, params: CreateKeyParams, idempotency_key: str = None) -> CreateKeyResponse:
+    def create_key(self, params: CreateKeyParams, idempotency_key: str | None = None) -> CreateKeyResponse:
         """
         Creates a new license key.
         :param params: Parameters for creating the key.
@@ -62,7 +68,7 @@ class KeyMint:
         """
         return self._handle_request('POST', '/key', params, idempotency_key=idempotency_key)
 
-    def activate_key(self, params: ActivateKeyParams, idempotency_key: str = None) -> ActivateKeyResponse:
+    def activate_key(self, params: ActivateKeyParams, idempotency_key: str | None = None) -> ActivateKeyResponse:
         """
         Activates a license key for a specific device.
 
@@ -77,7 +83,7 @@ class KeyMint:
         """
         return self._handle_request('POST', '/key/activate', params, idempotency_key=idempotency_key)
 
-    def deactivate_key(self, params: DeactivateKeyParams, idempotency_key: str = None) -> DeactivateKeyResponse:
+    def deactivate_key(self, params: DeactivateKeyParams, idempotency_key: str | None = None) -> DeactivateKeyResponse:
         """
         Deactivates a device from a license key.
         :param params: Parameters for deactivating the key.
@@ -86,7 +92,7 @@ class KeyMint:
         """
         return self._handle_request('POST', '/key/deactivate', params, idempotency_key=idempotency_key)
 
-    def floating_checkout(self, params: FloatingCheckoutParams, idempotency_key: str = None) -> FloatingCheckoutResponse:
+    def floating_checkout(self, params: FloatingCheckoutParams, idempotency_key: str | None = None) -> FloatingCheckoutResponse:
         """
         Checks out a floating license seat.
         :param params: Parameters for checking out the license.
@@ -95,7 +101,7 @@ class KeyMint:
         """
         return self._handle_request('POST', '/key/checkout', params, idempotency_key=idempotency_key)
 
-    def floating_heartbeat(self, params: FloatingHeartbeatParams, idempotency_key: str = None) -> FloatingHeartbeatResponse:
+    def floating_heartbeat(self, params: FloatingHeartbeatParams, idempotency_key: str | None = None) -> FloatingHeartbeatResponse:
         """
         Sends a heartbeat to keep a floating license session alive.
         :param params: Parameters for the heartbeat (includes rotating signature).
@@ -104,7 +110,7 @@ class KeyMint:
         """
         return self._handle_request('POST', '/key/heartbeat', params, idempotency_key=idempotency_key)
 
-    def floating_checkin(self, params: FloatingCheckinParams, idempotency_key: str = None) -> FloatingCheckinResponse:
+    def floating_checkin(self, params: FloatingCheckinParams, idempotency_key: str | None = None) -> FloatingCheckinResponse:
         """
         Checks in a floating license session, releasing the seat.
         :param params: Parameters for checking in the license (includes rotating signature).
@@ -120,12 +126,14 @@ class KeyMint:
         :returns: The license key details.
         """
         query_params = {
-            'productId': params['productId'],
-            'licenseKey': params['licenseKey']
+            'productId': params['productId']
         }
-        return self._handle_request('GET', '/key', query_params=query_params)
+        return self._handle_request(
+            'GET', '/key', query_params=query_params,
+            extra_headers={'x-license-key': params['licenseKey']}
+        )
 
-    def block_key(self, params: BlockKeyParams, idempotency_key: str = None) -> BlockKeyResponse:
+    def block_key(self, params: BlockKeyParams, idempotency_key: str | None = None) -> BlockKeyResponse:
         """
         Blocks a specific license key.
         :param params: Parameters for blocking the key.
@@ -134,7 +142,7 @@ class KeyMint:
         """
         return self._handle_request('POST', '/key/block', params, idempotency_key=idempotency_key)
 
-    def unblock_key(self, params: UnblockKeyParams, idempotency_key: str = None) -> UnblockKeyResponse:
+    def unblock_key(self, params: UnblockKeyParams, idempotency_key: str | None = None) -> UnblockKeyResponse:
         """
         Unblocks a previously blocked license key.
         :param params: Parameters for unblocking the key.
@@ -143,9 +151,29 @@ class KeyMint:
         """
         return self._handle_request('POST', '/key/unblock', params, idempotency_key=idempotency_key)
 
+    def update_key(self, params: 'UpdateKeyParams', idempotency_key: str | None = None) -> 'UpdateKeyResponse':
+        """
+        Updates an existing license key.
+        Requires productId and licenseKey. All other fields are optional.
+        :param params: Parameters for updating the key.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
+        :returns: The update confirmation.
+        """
+        return self._handle_request('PATCH', '/key', params, idempotency_key=idempotency_key)
+
+    def sign_key(self, params: 'SignKeyParams', idempotency_key: str | None = None) -> 'SignKeyResponse':
+        """
+        Signs a license key for offline (air-gapped) validation.
+        Requires admin API key scope and Standard plan.
+        :param params: Signing parameters (hostId is required).
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
+        :returns: The signed license file.
+        """
+        return self._handle_request('POST', '/key/sign', params, idempotency_key=idempotency_key)
+
     # Customer Management Methods
     
-    def create_customer(self, params: CreateCustomerParams, idempotency_key: str = None) -> CreateCustomerResponse:
+    def create_customer(self, params: CreateCustomerParams, idempotency_key: str | None = None) -> CreateCustomerResponse:
         """
         Creates a new customer.
         :param params: Parameters for creating the customer.
@@ -171,7 +199,7 @@ class KeyMint:
         query_params = {'customerId': params['customerId']}
         return self._handle_request('GET', '/customer/by-id', query_params=query_params)
 
-    def update_customer(self, params: UpdateCustomerParams, idempotency_key: str = None) -> UpdateCustomerResponse:
+    def update_customer(self, params: UpdateCustomerParams, idempotency_key: str | None = None) -> UpdateCustomerResponse:
         """
         Updates an existing customer's information.
         :param params: Parameters for updating the customer.
@@ -180,7 +208,7 @@ class KeyMint:
         """
         return self._handle_request('PUT', '/customer/by-id', params, idempotency_key=idempotency_key)
 
-    def delete_customer(self, params: DeleteCustomerParams, idempotency_key: str = None) -> DeleteCustomerResponse:
+    def delete_customer(self, params: DeleteCustomerParams, idempotency_key: str | None = None) -> DeleteCustomerResponse:
         """
         Permanently deletes a customer and all associated license keys.
         :param params: Parameters containing the customer ID.
@@ -190,16 +218,16 @@ class KeyMint:
         query_params = {'customerId': params['customerId']}
         return self._handle_request('DELETE', '/customer/by-id', query_params=query_params, idempotency_key=idempotency_key)
 
-    def get_customer_with_keys(self, params: GetCustomerWithKeysParams) -> GetCustomerWithKeysResponse:
+    def get_customer_with_keys(self, params: GetCustomerWithKeysParams) -> List[Dict[str, Any]]:
         """
-        Retrieves detailed information about a customer along with their license keys.
+        Retrieves license keys belonging to a specific customer.
         :param params: Parameters containing the customer ID.
-        :returns: The customer information with associated license keys.
+        :returns: A flat list of license key objects.
         """
         query_params = {'customerId': params['customerId']}
         return self._handle_request('GET', '/customer/keys', query_params=query_params)
 
-    def toggle_customer_status(self, params: ToggleCustomerStatusParams, idempotency_key: str = None) -> ToggleCustomerStatusResponse:
+    def toggle_customer_status(self, params: ToggleCustomerStatusParams, idempotency_key: str | None = None) -> ToggleCustomerStatusResponse:
         """
         Toggles the active status of a customer account (disable or enable).
         :param params: Parameters containing the customer ID.
@@ -219,8 +247,8 @@ class KeyMint:
         :param tolerance_seconds: Time tolerance in seconds to prevent replay attacks. Defaults to 300 (5 minutes).
         :returns: True if the signature is valid, False otherwise.
         """
-        import hmac
         import hashlib
+        import hmac
         import time
 
         if not header or not secret:
@@ -253,7 +281,7 @@ class KeyMint:
                 return False
 
             # Verify HMAC signature
-            signable_content = f"{timestamp_str}.{payload}".encode("utf-8")
+            signable_content = f"{timestamp_str}.{payload}".encode()
             expected_signature = hmac.new(
                 secret.encode("utf-8"),
                 signable_content,
@@ -265,4 +293,3 @@ class KeyMint:
         except Exception:
             return False
 
-

{keymint-2.3.1 → keymint-2.5.0}/keymint/_version.py

@@ -1,6 +1,6 @@
 """KeyMint Python SDK version information."""
 
-__version__ = "2.3.0"
+__version__ = "2.5.0"
 __author__ = "KeyMint"
 __email__ = "cliff@keymint.dev"
 __url__ = "https://github.com/keymint-dev/keymint-python"

{keymint-2.3.1 → keymint-2.5.0}/keymint/identity.py

@@ -10,14 +10,13 @@ import hashlib
 import hmac
 import os
 import platform
-import subprocess
-import uuid
 import re
+import subprocess
 import time
+import uuid
 from pathlib import Path
 from typing import Optional
 
-
 # ─── Garbage Detection ──────────────────────────────────────────────────
 
 _GARBAGE_PATTERNS = [
@@ -54,7 +53,7 @@ def _hash(value: str) -> str:
 
 # ─── Fingerprint Layers ────────────────────────────────────────────────
 
-def _get_bios_uuid() -> Optional[str]:
+def _get_bios_uuid() -> str | None:
     """Layer 1: BIOS / Hardware UUID."""
     system = platform.system()
     try:
@@ -82,7 +81,7 @@ def _get_bios_uuid() -> Optional[str]:
     return None
 
 
-def _get_os_machine_id() -> Optional[str]:
+def _get_os_machine_id() -> str | None:
     """Layer 2: OS-level persistent machine ID."""
     system = platform.system()
     try:
@@ -112,11 +111,11 @@ def _get_os_machine_id() -> Optional[str]:
     return None
 
 
-def _get_primary_mac() -> Optional[str]:
+def _get_primary_mac() -> str | None:
     """Layer 3: Primary network interface MAC address."""
     try:
-        import socket
         import fcntl
+        import socket
         import struct
     except ImportError:
         pass
@@ -136,7 +135,7 @@ def _get_primary_mac() -> Optional[str]:
 
 # ─── Public API ─────────────────────────────────────────────────────────
 
-def get_machine_id() -> Optional[str]:
+def get_machine_id() -> str | None:
     """
     Best-effort hardware fingerprint. Attempts to read the machine's
     BIOS/System UUID, then falls back through OS-level IDs and network
@@ -162,7 +161,7 @@ def get_machine_id() -> Optional[str]:
     return None
 
 
-def get_or_create_installation_id(storage_path: Optional[str] = None) -> str:
+def get_or_create_installation_id(storage_path: str | None = None) -> str:
     """
     Returns a guaranteed-unique, guaranteed-stable installation identifier.
     On first call, generates a UUIDv4 seeded with whatever hardware info
@@ -218,5 +217,5 @@ def generate_session_signature(session_id: str, nonce: str, session_secret: str)
         A 64-character hexadecimal signature string.
     """
     key_bytes = session_secret.encode('utf-8')
-    msg_bytes = f"{session_id}:{nonce}".encode('utf-8')
+    msg_bytes = f"{session_id}:{nonce}".encode()
     return hmac.new(key_bytes, msg_bytes, hashlib.sha256).hexdigest()

keymint-2.5.0/keymint/types.py

@@ -0,0 +1,287 @@
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class NewCustomer(TypedDict):
+    name: str
+    email: str | None
+
+class KeyFormat(TypedDict):
+    sections: int | None
+    sectionLength: int | None
+    separator: str | None
+    charset: str | None
+    prefix: str | None
+    suffix: str | None
+    case: str | None  # 'upper' | 'lower' | 'mixed'
+
+class CreateKeyParams(TypedDict):
+    productId: str
+    maxActivations: str | None
+    expiryDate: str | None
+    customerId: str | None
+    versionId: str | None
+    metadata: dict[str, Any] | None
+    newCustomer: NewCustomer | None
+    allowedHosts: list[str] | None
+    format: KeyFormat | None
+    amountKeys: str | None
+    licenseType: str | None  # 'node-locked' | 'floating'
+    maxConcurrentSessions: int | None
+    heartbeatInterval: int | None
+    sessionLeaseDuration: int | None
+
+class CreateKeyResponse(TypedDict, total=False):
+    code: int
+    key: str
+    keys: list[str]
+
+class KeyMintApiError(Exception):
+    def __init__(self, message: str, code: int, status: int | None = None):
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.status = status
+
+class ActivateKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+    hostId: str | None
+    deviceTag: str | None
+    licensee: dict[str, str] | None  # { name, email }
+    version: str | None
+
+class ActivateKeyResponse(TypedDict):
+    code: int
+    message: str
+    licenseeName: str | None
+    licenseeEmail: str | None
+    metadata: dict[str, Any] | None
+    versionId: str | None
+    version: dict[str, Any] | None
+    allowedHosts: list[str] | None
+
+class DeactivateKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+    hostId: str | None
+
+class DeactivateKeyResponse(TypedDict):
+    message: str
+    code: int
+    devicesRemoved: int
+
+class DeviceDetails(TypedDict):
+    hostId: str
+    deviceTag: str | None
+    ipAddress: str | None
+    activationTime: str
+
+class LicenseDetails(TypedDict):
+    id: str
+    key: str
+    productId: str
+    maxActivations: int
+    activations: int
+    devices: list[DeviceDetails]
+    activated: bool
+    expirationDate: str | None
+    versionId: str | None
+    metadata: dict[str, Any] | None
+    allowedHosts: list[str] | None
+    version: dict[str, Any] | None
+
+class CustomerDetails(TypedDict):
+    id: str
+    name: str | None
+    email: str | None
+    active: bool
+
+class GetKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+
+class GetKeyResponse(TypedDict):
+    data: dict[str, Any]
+    code: int
+
+class BlockKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+
+class BlockKeyResponse(TypedDict):
+    message: str
+    code: int
+
+class UnblockKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+
+class UnblockKeyResponse(TypedDict):
+    message: str
+    code: int
+
+# Customer Management Types
+
+class CreateCustomerParams(TypedDict):
+    name: str
+    email: str | None
+
+class CreateCustomerResponse(TypedDict):
+    action: str
+    status: bool
+    message: str
+    data: dict[str, Any]
+    code: int
+
+class GetAllCustomersParams(TypedDict):
+    page: int | None
+    limit: int | None
+    email: str | None
+
+class PaginationMeta(TypedDict):
+    total: int
+    page: int
+    limit: int
+    totalPages: int
+
+class GetAllCustomersResponse(TypedDict):
+    action: str
+    status: bool
+    data: list[dict[str, Any]]
+    meta: PaginationMeta | None
+    code: int
+
+class GetCustomerByIdParams(TypedDict):
+    customerId: str
+
+class GetCustomerByIdResponse(TypedDict):
+    action: str
+    status: bool
+    data: list[dict[str, Any]]
+    code: int
+
+class UpdateCustomerParams(TypedDict):
+    customerId: str
+    name: str | None  # Optional: Updated customer name
+    email: str | None # Optional: Updated customer email
+
+class UpdateCustomerResponse(TypedDict):
+    action: str
+    status: bool
+    code: int
+
+class DeleteCustomerParams(TypedDict):
+    customerId: str
+
+class DeleteCustomerResponse(TypedDict):
+    action: str
+    status: bool
+    code: int
+
+class ToggleCustomerStatusParams(TypedDict):
+    customerId: str
+
+class ToggleCustomerStatusResponse(TypedDict, total=False):
+    action: str
+    status: bool
+    message: str
+    code: int
+    customerName: str
+    active: bool
+
+class CustomerLicenseKey(TypedDict):
+    id: str
+    key: str
+    productId: str
+    maxActivations: int
+    activations: int
+    activated: bool
+    expirationDate: str | None
+    versionId: str | None
+    metadata: dict[str, Any] | None
+    allowedHosts: list[str] | None
+
+class GetCustomerWithKeysParams(TypedDict):
+    customerId: str
+
+# GetCustomerWithKeys returns a flat LicenseKey[] — no wrapper object.
+# Use List[Dict[str, Any]] for the response type.
+
+class FloatingCheckoutParams(TypedDict):
+    productId: str
+    licenseKey: str
+    hostId: str
+    deviceTag: str | None
+    userIdentifier: str | None
+    apiKey: str | None
+    timestamp: Any | None
+    signature: str | None
+
+class FloatingCheckoutResponse(TypedDict):
+    code: int
+    message: str
+    sessionId: str
+    sessionSecret: str
+    nextNonce: str
+    expiresAt: str
+    heartbeatInterval: int
+    metadata: dict[str, Any] | None
+    currentSessions: int | None
+    maxSessions: int | None
+    licenseeName: str | None
+    licenseeEmail: str | None
+
+class FloatingHeartbeatParams(TypedDict):
+    productId: str
+    licenseKey: str
+    sessionId: str
+    timestamp: Any  # rotating nonce (nextNonce) received from previous response
+    signature: str
+    apiKey: str | None
+
+class FloatingHeartbeatResponse(TypedDict):
+    code: int
+    message: str
+    expiresAt: str
+    nextNonce: str
+
+class FloatingCheckinParams(TypedDict):
+    productId: str
+    licenseKey: str
+    sessionId: str
+    timestamp: Any  # rotating nonce (nextNonce) received from previous response
+    signature: str
+    apiKey: str | None
+
+class FloatingCheckinResponse(TypedDict):
+    code: int
+    message: str
+
+class UpdateKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+    maxActivations: Any | None   # string or number
+    expiryDate: str | None
+    customerId: str | None
+    newCustomer: NewCustomer | None
+    metadata: dict[str, Any] | None
+    versionId: str | None
+    allowedHosts: list[str] | None
+    licenseType: str | None  # 'node-locked' | 'floating'
+    maxConcurrentSessions: int | None
+    heartbeatInterval: int | None
+    sessionLeaseDuration: int | None
+
+class UpdateKeyResponse(TypedDict):
+    code: int
+    message: str
+    affectedCount: int | None
+
+class SignKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+    hostId: str
+    ttl: int | None
+
+class SignKeyResponse(TypedDict):
+    file: str  # Serialized signed license file returned by the API

{keymint-2.3.1 → keymint-2.5.0/keymint.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keymint
-Version: 2.3.1
+Version: 2.5.0
 Summary: License key validation, activation, and management for Python. Supports node-locking, offline licensing, and hardware fingerprinting.
 Home-page: https://github.com/keymint-dev/keymint-python
 Author: KeyMint
@@ -16,18 +16,14 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Software Distribution
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.25.0
+Requires-Dist: requests>=2.32.4
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -107,8 +103,10 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `activate_key`   | Activates a license key for a device.           |
 | `deactivate_key` | Deactivates a device from a license key.        |
 | `get_key`        | Retrieves detailed information about a key.     |
+| `update_key`     | Updates an existing license key.                |
 | `block_key`      | Blocks a license key.                           |
 | `unblock_key`    | Unblocks a previously blocked license key.      |
+| `sign_key`       | Signs a key for offline validation using an admin API key.|
 | `floating_checkout` | Checks out a floating license seat.          |
 | `floating_heartbeat`| Sends a heartbeat to keep a session alive.   |
 | `floating_checkin`  | Checks in a session, releasing the seat.     |

{keymint-2.3.1 → keymint-2.5.0}/keymint.egg-info/SOURCES.txt

@@ -10,4 +10,5 @@ keymint.egg-info/PKG-INFO
 keymint.egg-info/SOURCES.txt
 keymint.egg-info/dependency_links.txt
 keymint.egg-info/requires.txt
-keymint.egg-info/top_level.txt
+keymint.egg-info/top_level.txt
+tests/test_contracts.py

{keymint-2.3.1 → keymint-2.5.0}/keymint.egg-info/requires.txt

@@ -1,4 +1,4 @@
-requests>=2.25.0
+requests>=2.32.4
 
 [dev]
 pytest>=6.0

{keymint-2.3.1 → keymint-2.5.0}/setup.py

@@ -1,11 +1,11 @@
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 
 with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 
 setup(
     name="keymint",
-    version="2.3.1",
+    version="2.5.0",
     author="KeyMint",
     author_email="cliff@keymint.dev",
     description="License key validation, activation, and management for Python. Supports node-locking, offline licensing, and hardware fingerprinting.",
@@ -26,19 +26,15 @@ setup(
         "Topic :: System :: Software Distribution",
         "License :: OSI Approved :: MIT License",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
         "Operating System :: OS Independent",
     ],
     keywords="license-key validation activation node-lock hardware-id copy-protection product-key drm offline-licensing keymint license licensing api",
-    python_requires='>=3.6',
+    python_requires='>=3.10',
     install_requires=[
-        'requests>=2.25.0',
+        'requests>=2.32.4',
     ],
     extras_require={
         'dev': [

keymint-2.5.0/tests/test_contracts.py

@@ -0,0 +1,52 @@
+from unittest.mock import Mock, patch
+
+import pytest
+import requests
+
+from keymint import KeyMint, KeyMintApiError
+
+
+def response(payload, status=200):
+    result = Mock()
+    result.json.return_value = payload
+    result.status_code = status
+    if status >= 400:
+        error = requests.exceptions.HTTPError()
+        error.response = result
+        result.raise_for_status.side_effect = error
+    return result
+
+
+@patch("keymint.requests.get")
+def test_get_key_uses_header_not_query(mock_get):
+    mock_get.return_value = response({"code": 0, "data": {"license": {"productId": "product 123"}}})
+
+    KeyMint("readonly_test").get_key({"productId": "product 123", "licenseKey": "secret/license+key"})
+
+    _, kwargs = mock_get.call_args
+    assert kwargs["params"] == {"productId": "product 123"}
+    assert kwargs["headers"]["x-license-key"] == "secret/license+key"
+    assert "licenseKey" not in kwargs["params"]
+
+
+@patch("keymint.requests.post")
+def test_sign_key_returns_serialized_file(mock_post):
+    mock_post.return_value = response({"file": '{"signedKey":"signature","keyId":"key_123"}'})
+
+    result = KeyMint("admin_test").sign_key({
+        "productId": "product_123", "licenseKey": "license_123", "hostId": "host_123"
+    })
+
+    assert isinstance(result["file"], str)
+
+
+@patch("keymint.requests.post")
+def test_nested_error_preserves_server_message(mock_post):
+    mock_post.return_value = response({
+        "success": False,
+        "error": {"code": "CUSTOMER_EMAIL_EXISTS", "message": "Customer email already exists in team"},
+        "code": 1,
+    }, 409)
+
+    with pytest.raises(KeyMintApiError, match="Customer email already exists in team"):
+        KeyMint("admin_test").create_key({"productId": "product_123"})

keymint-2.3.1/keymint/types.py

@@ -1,237 +0,0 @@
-from typing import TypedDict, Optional, List, Dict, Any
-
-class NewCustomer(TypedDict):
-    name: str
-    email: Optional[str]
-
-class CreateKeyParams(TypedDict):
-    productId: str
-    maxActivations: Optional[str]
-    expiryDate: Optional[str]
-    customerId: Optional[str]
-    versionId: Optional[str]
-    metadata: Optional[Dict[str, Any]]
-    newCustomer: Optional[NewCustomer]
-    allowedHosts: Optional[List[str]]
-
-class CreateKeyResponse(TypedDict):
-    code: int
-    key: str
-
-class KeyMintApiError(Exception):
-    def __init__(self, message: str, code: int, status: Optional[int] = None):
-        super().__init__(message)
-        self.message = message
-        self.code = code
-        self.status = status
-
-class ActivateKeyParams(TypedDict):
-    productId: str
-    licenseKey: str
-    hostId: Optional[str]
-    deviceTag: Optional[str]
-
-class ActivateKeyResponse(TypedDict):
-    code: int
-    message: str
-    licenseeName: Optional[str]
-    licenseeEmail: Optional[str]
-    metadata: Optional[Dict[str, Any]]
-    versionId: Optional[str]
-    version: Optional[Dict[str, Any]]
-    allowedHosts: Optional[List[str]]
-
-class DeactivateKeyParams(TypedDict):
-    productId: str
-    licenseKey: str
-    hostId: Optional[str]
-
-class DeactivateKeyResponse(TypedDict):
-    message: str
-    code: int
-
-class DeviceDetails(TypedDict):
-    hostId: str
-    deviceTag: Optional[str]
-    ipAddress: Optional[str]
-    activationTime: str
-
-class LicenseDetails(TypedDict):
-    id: str
-    key: str
-    productId: str
-    maxActivations: int
-    activations: int
-    devices: List[DeviceDetails]
-    activated: bool
-    expirationDate: Optional[str]
-    versionId: Optional[str]
-    metadata: Optional[Dict[str, Any]]
-    allowedHosts: Optional[List[str]]
-    version: Optional[Dict[str, Any]]
-
-class CustomerDetails(TypedDict):
-    id: str
-    name: Optional[str]
-    email: Optional[str]
-    active: bool
-
-class GetKeyParams(TypedDict):
-    productId: str
-    licenseKey: str
-
-class GetKeyResponse(TypedDict):
-    data: Dict[str, Any]
-    code: int
-
-class BlockKeyParams(TypedDict):
-    productId: str
-    licenseKey: str
-
-class BlockKeyResponse(TypedDict):
-    message: str
-    code: int
-
-class UnblockKeyParams(TypedDict):
-    productId: str
-    licenseKey: str
-
-class UnblockKeyResponse(TypedDict):
-    message: str
-    code: int
-
-# Customer Management Types
-
-class CreateCustomerParams(TypedDict):
-    name: str
-    email: str
-
-class CreateCustomerResponse(TypedDict):
-    action: str
-    status: bool
-    message: str
-    data: Dict[str, Any]
-    code: int
-
-class GetAllCustomersParams(TypedDict):
-    page: Optional[int]
-    limit: Optional[int]
-    email: Optional[str]
-
-class PaginationMeta(TypedDict):
-    total: int
-    page: int
-    limit: int
-    totalPages: int
-
-class GetAllCustomersResponse(TypedDict):
-    action: str
-    status: bool
-    data: List[Dict[str, Any]]
-    meta: Optional[PaginationMeta]
-    code: int
-
-class GetCustomerByIdParams(TypedDict):
-    customerId: str
-
-class GetCustomerByIdResponse(TypedDict):
-    action: str
-    status: bool
-    data: List[Dict[str, Any]]
-    code: int
-
-class UpdateCustomerParams(TypedDict):
-    name: str
-    email: str
-    customerId: str
-
-class UpdateCustomerResponse(TypedDict):
-    action: str
-    status: bool
-    code: int
-
-class DeleteCustomerParams(TypedDict):
-    customerId: str
-
-class DeleteCustomerResponse(TypedDict):
-    action: str
-    status: bool
-    code: int
-
-class ToggleCustomerStatusParams(TypedDict):
-    customerId: str
-
-class ToggleCustomerStatusResponse(TypedDict):
-    action: str
-    status: bool
-    message: str
-    code: int
-
-class CustomerLicenseKey(TypedDict):
-    id: str
-    key: str
-    productId: str
-    maxActivations: int
-    activations: int
-    activated: bool
-    expirationDate: Optional[str]
-    versionId: Optional[str]
-    metadata: Optional[Dict[str, Any]]
-    allowedHosts: Optional[List[str]]
-
-class GetCustomerWithKeysParams(TypedDict):
-    customerId: str
-
-class GetCustomerWithKeysResponse(TypedDict):
-    action: str
-    status: bool
-    data: Dict[str, Any]  # Contains customer and licenseKeys
-    code: int
-
-class FloatingCheckoutParams(TypedDict):
-    productId: str
-    licenseKey: str
-    hostId: str
-    deviceTag: Optional[str]
-    userIdentifier: Optional[str]
-    apiKey: Optional[str]
-
-class FloatingCheckoutResponse(TypedDict):
-    code: int
-    message: str
-    sessionId: str
-    sessionSecret: str
-    nextNonce: str
-    expiresAt: str
-    heartbeatInterval: int
-    metadata: Optional[Dict[str, Any]]
-    currentSessions: Optional[int]
-    maxSessions: Optional[int]
-    licenseeName: Optional[str]
-    licenseeEmail: Optional[str]
-
-class FloatingHeartbeatParams(TypedDict):
-    productId: str
-    licenseKey: str
-    sessionId: str
-    timestamp: Any  # rotating nonce (nextNonce) received from previous response
-    signature: str
-    apiKey: Optional[str]
-
-class FloatingHeartbeatResponse(TypedDict):
-    code: int
-    message: str
-    expiresAt: str
-    nextNonce: str
-
-class FloatingCheckinParams(TypedDict):
-    productId: str
-    licenseKey: str
-    sessionId: str
-    timestamp: Any  # rotating nonce (nextNonce) received from previous response
-    signature: str
-    apiKey: Optional[str]
-
-class FloatingCheckinResponse(TypedDict):
-    code: int
-    message: str