keymint 2.4.0__tar.gz → 2.6.0__tar.gz

{keymint-2.4.0/keymint.egg-info → keymint-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keymint
-Version: 2.4.0
+Version: 2.6.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"
@@ -91,6 +87,30 @@ if result and 'key' in result:
     print(f"Created Key: {result['key']}")
 ```
 
+## License Expiry
+
+`activate_key` and `floating_checkout` return `expirationDate`: the license expiry as an ISO 8601 string (e.g. `"2027-03-01T00:00:00.000Z"`), or `None` when the license never expires. On `floating_checkout`, `expiresAt` is the seat lease, not the license expiry.
+
+```python
+from datetime import datetime, timezone
+import math
+
+result = sdk.activate_key({'productId': product_id, 'licenseKey': license_key, 'hostId': host_id})
+
+expiration = result.get('expirationDate')
+if expiration is None:
+    print('License never expires')
+else:
+    expires_at = datetime.fromisoformat(expiration.replace('Z', '+00:00'))
+    seconds_left = (expires_at - datetime.now(timezone.utc)).total_seconds()
+    days_left = max(0, math.ceil(seconds_left / 86400))
+    print(f'License expires {expires_at:%Y-%m-%d} ({days_left} days left)')
+
+# Store the last value you received (e.g. in your app's settings file).
+```
+
+Store the last `expirationDate` you received. An expired license fails activation with the same generic invalid-key error as a wrong key, so the stored date is how your app can tell the user the license expired on that date instead of calling the key invalid.
+
 ## Machine Identity
 Keymint provides utilities to uniquely identify machines for node-locking:
 
@@ -110,7 +130,7 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `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 (air-gapped) validation.|
+| `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.4.0 → keymint-2.6.0}/README.md

@@ -42,6 +42,30 @@ if result and 'key' in result:
     print(f"Created Key: {result['key']}")
 ```
 
+## License Expiry
+
+`activate_key` and `floating_checkout` return `expirationDate`: the license expiry as an ISO 8601 string (e.g. `"2027-03-01T00:00:00.000Z"`), or `None` when the license never expires. On `floating_checkout`, `expiresAt` is the seat lease, not the license expiry.
+
+```python
+from datetime import datetime, timezone
+import math
+
+result = sdk.activate_key({'productId': product_id, 'licenseKey': license_key, 'hostId': host_id})
+
+expiration = result.get('expirationDate')
+if expiration is None:
+    print('License never expires')
+else:
+    expires_at = datetime.fromisoformat(expiration.replace('Z', '+00:00'))
+    seconds_left = (expires_at - datetime.now(timezone.utc)).total_seconds()
+    days_left = max(0, math.ceil(seconds_left / 86400))
+    print(f'License expires {expires_at:%Y-%m-%d} ({days_left} days left)')
+
+# Store the last value you received (e.g. in your app's settings file).
+```
+
+Store the last `expirationDate` you received. An expired license fails activation with the same generic invalid-key error as a wrong key, so the stored date is how your app can tell the user the license expired on that date instead of calling the key invalid.
+
 ## Machine Identity
 Keymint provides utilities to uniquely identify machines for node-locking:
 
@@ -61,7 +85,7 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `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 (air-gapped) validation.|
+| `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.4.0 → keymint-2.6.0}/keymint/__init__.py

@@ -17,11 +17,13 @@ class KeyMint:
             'Content-Type': 'application/json'
         }
 
-    def _handle_request(self, method: str, endpoint: str, params: dict | None = None, query_params: dict | None = None, idempotency_key: str | None = 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':
@@ -42,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
                 )
@@ -76,7 +79,10 @@ class KeyMint:
         
         :param params: Activation parameters including productId, licenseKey, and optional hostId.
         :param idempotency_key: Optional unique identifier to ensure request idempotency.
-        :return: Activation success message and licensee information.
+        :return: Activation success message and licensee information. Includes
+            ``expirationDate``: the license expiry as an ISO 8601 string, or ``None``
+            when the license never expires. An expired license fails activation with
+            the same generic invalid-key error, so store the last value you received.
         """
         return self._handle_request('POST', '/key/activate', params, idempotency_key=idempotency_key)
 
@@ -95,6 +101,8 @@ class KeyMint:
         :param params: Parameters for checking out the license.
         :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The checkout response containing sessionId and sessionSecret.
+            ``expiresAt`` is the seat lease; ``expirationDate`` is the license expiry
+            as an ISO 8601 string, or ``None`` when the license never expires.
         """
         return self._handle_request('POST', '/key/checkout', params, idempotency_key=idempotency_key)
 
@@ -123,10 +131,12 @@ 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 = None) -> BlockKeyResponse:
         """
@@ -288,4 +298,3 @@ class KeyMint:
         except Exception:
             return False
 
-

{keymint-2.4.0 → keymint-2.6.0}/keymint/_version.py

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

{keymint-2.4.0 → keymint-2.6.0}/keymint/types.py

@@ -30,9 +30,10 @@ class CreateKeyParams(TypedDict):
     heartbeatInterval: int | None
     sessionLeaseDuration: int | None
 
-class CreateKeyResponse(TypedDict):
+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):
@@ -58,6 +59,9 @@ class ActivateKeyResponse(TypedDict):
     versionId: str | None
     version: dict[str, Any] | None
     allowedHosts: list[str] | None
+    # License expiry as an ISO 8601 string (e.g. "2027-03-01T00:00:00.000Z"),
+    # or None when the license never expires.
+    expirationDate: str | None
 
 class DeactivateKeyParams(TypedDict):
     productId: str
@@ -67,6 +71,7 @@ class DeactivateKeyParams(TypedDict):
 class DeactivateKeyResponse(TypedDict):
     message: str
     code: int
+    devicesRemoved: int
 
 class DeviceDetails(TypedDict):
     hostId: str
@@ -179,11 +184,13 @@ class DeleteCustomerResponse(TypedDict):
 class ToggleCustomerStatusParams(TypedDict):
     customerId: str
 
-class ToggleCustomerStatusResponse(TypedDict):
+class ToggleCustomerStatusResponse(TypedDict, total=False):
     action: str
     status: bool
     message: str
     code: int
+    customerName: str
+    active: bool
 
 class CustomerLicenseKey(TypedDict):
     id: str
@@ -210,6 +217,8 @@ class FloatingCheckoutParams(TypedDict):
     deviceTag: str | None
     userIdentifier: str | None
     apiKey: str | None
+    timestamp: Any | None
+    signature: str | None
 
 class FloatingCheckoutResponse(TypedDict):
     code: int
@@ -217,9 +226,12 @@ class FloatingCheckoutResponse(TypedDict):
     sessionId: str
     sessionSecret: str
     nextNonce: str
-    expiresAt: str
+    expiresAt: str  # Floating seat lease expiry (not the license expiry)
     heartbeatInterval: int
     metadata: dict[str, Any] | None
+    # License expiry as an ISO 8601 string, or None when the license never
+    # expires. Separate from ``expiresAt``, which is the seat lease.
+    expirationDate: str | None
     currentSessions: int | None
     maxSessions: int | None
     licenseeName: str | None
@@ -278,5 +290,4 @@ class SignKeyParams(TypedDict):
     ttl: int | None
 
 class SignKeyResponse(TypedDict):
-    code: int
-    file: dict[str, Any]  # { signedKey, keyId, publicKeyFingerprint }
+    file: str  # Serialized signed license file returned by the API

{keymint-2.4.0 → keymint-2.6.0/keymint.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keymint
-Version: 2.4.0
+Version: 2.6.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"
@@ -91,6 +87,30 @@ if result and 'key' in result:
     print(f"Created Key: {result['key']}")
 ```
 
+## License Expiry
+
+`activate_key` and `floating_checkout` return `expirationDate`: the license expiry as an ISO 8601 string (e.g. `"2027-03-01T00:00:00.000Z"`), or `None` when the license never expires. On `floating_checkout`, `expiresAt` is the seat lease, not the license expiry.
+
+```python
+from datetime import datetime, timezone
+import math
+
+result = sdk.activate_key({'productId': product_id, 'licenseKey': license_key, 'hostId': host_id})
+
+expiration = result.get('expirationDate')
+if expiration is None:
+    print('License never expires')
+else:
+    expires_at = datetime.fromisoformat(expiration.replace('Z', '+00:00'))
+    seconds_left = (expires_at - datetime.now(timezone.utc)).total_seconds()
+    days_left = max(0, math.ceil(seconds_left / 86400))
+    print(f'License expires {expires_at:%Y-%m-%d} ({days_left} days left)')
+
+# Store the last value you received (e.g. in your app's settings file).
+```
+
+Store the last `expirationDate` you received. An expired license fails activation with the same generic invalid-key error as a wrong key, so the stored date is how your app can tell the user the license expired on that date instead of calling the key invalid.
+
 ## Machine Identity
 Keymint provides utilities to uniquely identify machines for node-locking:
 
@@ -110,7 +130,7 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `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 (air-gapped) validation.|
+| `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.4.0 → keymint-2.6.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.4.0 → keymint-2.6.0}/keymint.egg-info/requires.txt

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

{keymint-2.4.0 → keymint-2.6.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="keymint",
-    version="2.4.0",
+    version="2.6.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.6.0/tests/test_contracts.py

@@ -0,0 +1,85 @@
+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"})
+
+
+@pytest.mark.parametrize("expiration_date", ["2027-03-01T00:00:00.000Z", None])
+@patch("keymint.requests.post")
+def test_activate_key_returns_expiration_date(mock_post, expiration_date):
+    mock_post.return_value = response({
+        "code": 0, "message": "License valid", "expirationDate": expiration_date,
+    })
+
+    result = KeyMint("client_test").activate_key({"productId": "product_123", "licenseKey": "license_123"})
+
+    assert mock_post.call_args.args[0].endswith("/key/activate")
+    assert "expirationDate" in result
+    assert result["expirationDate"] == expiration_date
+
+
+@pytest.mark.parametrize("expiration_date", ["2027-03-01T00:00:00.000Z", None])
+@patch("keymint.requests.post")
+def test_floating_checkout_returns_expiration_date_separate_from_lease(mock_post, expiration_date):
+    mock_post.return_value = response({
+        "code": 0, "message": "Checked out", "sessionId": "session_123",
+        "sessionSecret": "secret_123", "nextNonce": "nonce_123",
+        "expiresAt": "2026-10-26T12:05:00.000Z", "heartbeatInterval": 60,
+        "metadata": None, "expirationDate": expiration_date,
+    })
+
+    result = KeyMint("client_test").floating_checkout({
+        "productId": "product_123", "licenseKey": "license_123", "hostId": "host_123",
+    })
+
+    assert mock_post.call_args.args[0].endswith("/key/checkout")
+    assert result["expirationDate"] == expiration_date
+    assert result["expiresAt"] == "2026-10-26T12:05:00.000Z"