keymint 2.1.1__tar.gz → 2.3.0__tar.gz

{keymint-2.1.1/keymint.egg-info → keymint-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keymint
-Version: 2.1.1
+Version: 2.3.0
 Summary: Official Python SDK for KeyMint license management with comprehensive API coverage.
 Home-page: https://github.com/keymint-dev/keymint-python
 Author: KeyMint
@@ -70,13 +70,13 @@ pip install keymint
 import os
 from keymint import KeyMint, identity
 
-access_token = os.environ.get('KEYMINT_ACCESS_TOKEN')
+api_key = os.environ.get('KEYMINT_API_KEY')
 product_id = os.environ.get('KEYMINT_PRODUCT_ID')
 
-if not access_token or not product_id:
-    raise ValueError('Please set the KEYMINT_ACCESS_TOKEN and KEYMINT_PRODUCT_ID environment variables.')
+if not api_key or not product_id:
+    raise ValueError('Please set the KEYMINT_API_KEY and KEYMINT_PRODUCT_ID environment variables.')
 
-sdk = KeyMint(access_token)
+sdk = KeyMint(api_key)
 
 # 1. Get a stable, unique ID for this machine
 host_id = identity.get_or_create_installation_id()
@@ -109,6 +109,9 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `get_key`        | Retrieves detailed information about a key.     |
 | `block_key`      | Blocks a license key.                           |
 | `unblock_key`    | Unblocks a previously blocked license 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.     |
 
 ### Customer Management
 
@@ -122,6 +125,22 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `toggle_customer_status`| Toggles customer active status.                  |
 | `delete_customer`       | Permanently deletes a customer and their keys.   |
 
+### Webhook Verification
+
+| Method                  | Description                                      |
+|-------------------------|--------------------------------------------------|
+| `verify_webhook_signature`| Verifies the signature of a webhook request payload. |
+
+## Idempotency
+
+All mutating SDK methods support idempotency keys to safely retry requests in case of network drops. Pass a unique string (recommended: UUID v4) as the optional `idempotency_key` keyword argument:
+
+```python
+result = sdk.create_key({ 
+    'productId': product_id,
+}, idempotency_key='9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d')
+```
+
 ## License
 MIT
 

{keymint-2.1.1 → keymint-2.3.0}/README.md

@@ -21,13 +21,13 @@ pip install keymint
 import os
 from keymint import KeyMint, identity
 
-access_token = os.environ.get('KEYMINT_ACCESS_TOKEN')
+api_key = os.environ.get('KEYMINT_API_KEY')
 product_id = os.environ.get('KEYMINT_PRODUCT_ID')
 
-if not access_token or not product_id:
-    raise ValueError('Please set the KEYMINT_ACCESS_TOKEN and KEYMINT_PRODUCT_ID environment variables.')
+if not api_key or not product_id:
+    raise ValueError('Please set the KEYMINT_API_KEY and KEYMINT_PRODUCT_ID environment variables.')
 
-sdk = KeyMint(access_token)
+sdk = KeyMint(api_key)
 
 # 1. Get a stable, unique ID for this machine
 host_id = identity.get_or_create_installation_id()
@@ -60,6 +60,9 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `get_key`        | Retrieves detailed information about a key.     |
 | `block_key`      | Blocks a license key.                           |
 | `unblock_key`    | Unblocks a previously blocked license 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.     |
 
 ### Customer Management
 
@@ -73,6 +76,22 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `toggle_customer_status`| Toggles customer active status.                  |
 | `delete_customer`       | Permanently deletes a customer and their keys.   |
 
+### Webhook Verification
+
+| Method                  | Description                                      |
+|-------------------------|--------------------------------------------------|
+| `verify_webhook_signature`| Verifies the signature of a webhook request payload. |
+
+## Idempotency
+
+All mutating SDK methods support idempotency keys to safely retry requests in case of network drops. Pass a unique string (recommended: UUID v4) as the optional `idempotency_key` keyword argument:
+
+```python
+result = sdk.create_key({ 
+    'productId': product_id,
+}, idempotency_key='9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d')
+```
+
 ## License
 MIT
 

{keymint-2.1.1 → keymint-2.3.0}/keymint/__init__.py

@@ -16,17 +16,21 @@ class KeyMint:
             'Content-Type': 'application/json'
         }
 
-    def _handle_request(self, method: str, endpoint: str, params: dict = None, query_params: dict = None):
+    def _handle_request(self, method: str, endpoint: str, params: dict = None, query_params: dict = None, idempotency_key: str = None):
         url = f'{self.base_url}{endpoint}'
+        headers = self.headers.copy()
+        if idempotency_key:
+            headers['Idempotency-Key'] = idempotency_key
+            
         try:
             if method.upper() == 'GET':
-                response = requests.get(url, params=query_params, headers=self.headers)
+                response = requests.get(url, params=query_params, headers=headers)
             elif method.upper() == 'POST':
-                response = requests.post(url, json=params, headers=self.headers)
+                response = requests.post(url, json=params, headers=headers)
             elif method.upper() == 'PUT':
-                response = requests.put(url, json=params, headers=self.headers)
+                response = requests.put(url, json=params, headers=headers)
             elif method.upper() == 'DELETE':
-                response = requests.delete(url, params=query_params, headers=self.headers)
+                response = requests.delete(url, params=query_params, headers=headers)
             else:
                 raise ValueError(f"Unsupported HTTP method: {method}")
             
@@ -49,15 +53,16 @@ class KeyMint:
         except Exception as err:
             raise KeyMintApiError(message=str(err), code=-1)
 
-    def create_key(self, params: CreateKeyParams) -> CreateKeyResponse:
+    def create_key(self, params: CreateKeyParams, idempotency_key: str = None) -> CreateKeyResponse:
         """
         Creates a new license key.
         :param params: Parameters for creating the key.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The created key information.
         """
-        return self._handle_request('POST', '/key', params)
+        return self._handle_request('POST', '/key', params, idempotency_key=idempotency_key)
 
-    def activate_key(self, params: ActivateKeyParams) -> ActivateKeyResponse:
+    def activate_key(self, params: ActivateKeyParams, idempotency_key: str = None) -> ActivateKeyResponse:
         """
         Activates a license key for a specific device.
 
@@ -67,41 +72,46 @@ class KeyMint:
         MUST cache the validation result locally.
         
         :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 self._handle_request('POST', '/key/activate', params)
+        return self._handle_request('POST', '/key/activate', params, idempotency_key=idempotency_key)
 
-    def deactivate_key(self, params: DeactivateKeyParams) -> DeactivateKeyResponse:
+    def deactivate_key(self, params: DeactivateKeyParams, idempotency_key: str = None) -> DeactivateKeyResponse:
         """
         Deactivates a device from a license key.
         :param params: Parameters for deactivating the key.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The deactivation confirmation.
         """
-        return self._handle_request('POST', '/key/deactivate', params)
+        return self._handle_request('POST', '/key/deactivate', params, idempotency_key=idempotency_key)
 
-    def floating_checkout(self, params: FloatingCheckoutParams) -> FloatingCheckoutResponse:
+    def floating_checkout(self, params: FloatingCheckoutParams, idempotency_key: str = None) -> FloatingCheckoutResponse:
         """
         Checks out a floating license seat.
         :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.
         """
-        return self._handle_request('POST', '/key/checkout', params)
+        return self._handle_request('POST', '/key/checkout', params, idempotency_key=idempotency_key)
 
-    def floating_heartbeat(self, params: FloatingHeartbeatParams) -> FloatingHeartbeatResponse:
+    def floating_heartbeat(self, params: FloatingHeartbeatParams, idempotency_key: str = None) -> FloatingHeartbeatResponse:
         """
         Sends a heartbeat to keep a floating license session alive.
         :param params: Parameters for the heartbeat (includes rotating signature).
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The heartbeat response with extended expiry and new nonce.
         """
-        return self._handle_request('POST', '/key/heartbeat', params)
+        return self._handle_request('POST', '/key/heartbeat', params, idempotency_key=idempotency_key)
 
-    def floating_checkin(self, params: FloatingCheckinParams) -> FloatingCheckinResponse:
+    def floating_checkin(self, params: FloatingCheckinParams, idempotency_key: str = None) -> FloatingCheckinResponse:
         """
         Checks in a floating license session, releasing the seat.
         :param params: Parameters for checking in the license (includes rotating signature).
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The checkin confirmation.
         """
-        return self._handle_request('POST', '/key/checkin', params)
+        return self._handle_request('POST', '/key/checkin', params, idempotency_key=idempotency_key)
 
     def get_key(self, params: GetKeyParams) -> GetKeyResponse:
         """
@@ -115,31 +125,34 @@ class KeyMint:
         }
         return self._handle_request('GET', '/key', query_params=query_params)
 
-    def block_key(self, params: BlockKeyParams) -> BlockKeyResponse:
+    def block_key(self, params: BlockKeyParams, idempotency_key: str = None) -> BlockKeyResponse:
         """
         Blocks a specific license key.
         :param params: Parameters for blocking the key.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The block confirmation.
         """
-        return self._handle_request('POST', '/key/block', params)
+        return self._handle_request('POST', '/key/block', params, idempotency_key=idempotency_key)
 
-    def unblock_key(self, params: UnblockKeyParams) -> UnblockKeyResponse:
+    def unblock_key(self, params: UnblockKeyParams, idempotency_key: str = None) -> UnblockKeyResponse:
         """
         Unblocks a previously blocked license key.
         :param params: Parameters for unblocking the key.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The unblock confirmation.
         """
-        return self._handle_request('POST', '/key/unblock', params)
+        return self._handle_request('POST', '/key/unblock', params, idempotency_key=idempotency_key)
 
     # Customer Management Methods
     
-    def create_customer(self, params: CreateCustomerParams) -> CreateCustomerResponse:
+    def create_customer(self, params: CreateCustomerParams, idempotency_key: str = None) -> CreateCustomerResponse:
         """
         Creates a new customer.
         :param params: Parameters for creating the customer.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The created customer information.
         """
-        return self._handle_request('POST', '/customer', params)
+        return self._handle_request('POST', '/customer', params, idempotency_key=idempotency_key)
 
     def get_all_customers(self, params: Optional[GetAllCustomersParams] = None) -> GetAllCustomersResponse:
         """
@@ -158,22 +171,24 @@ 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) -> UpdateCustomerResponse:
+    def update_customer(self, params: UpdateCustomerParams, idempotency_key: str = None) -> UpdateCustomerResponse:
         """
         Updates an existing customer's information.
         :param params: Parameters for updating the customer.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The update confirmation.
         """
-        return self._handle_request('PUT', '/customer/by-id', params)
+        return self._handle_request('PUT', '/customer/by-id', params, idempotency_key=idempotency_key)
 
-    def delete_customer(self, params: DeleteCustomerParams) -> DeleteCustomerResponse:
+    def delete_customer(self, params: DeleteCustomerParams, idempotency_key: str = None) -> DeleteCustomerResponse:
         """
         Permanently deletes a customer and all associated license keys.
         :param params: Parameters containing the customer ID.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The deletion confirmation.
         """
         query_params = {'customerId': params['customerId']}
-        return self._handle_request('DELETE', '/customer/by-id', query_params=query_params)
+        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:
         """
@@ -184,12 +199,70 @@ class KeyMint:
         query_params = {'customerId': params['customerId']}
         return self._handle_request('GET', '/customer/keys', query_params=query_params)
 
-    def toggle_customer_status(self, params: ToggleCustomerStatusParams) -> ToggleCustomerStatusResponse:
+    def toggle_customer_status(self, params: ToggleCustomerStatusParams, idempotency_key: str = None) -> ToggleCustomerStatusResponse:
         """
         Toggles the active status of a customer account (disable or enable).
         :param params: Parameters containing the customer ID.
+        :param idempotency_key: Optional unique identifier to ensure request idempotency.
         :returns: The status toggle confirmation.
         """
         query_params = {'customerId': params['customerId']}
-        return self._handle_request('POST', '/customer/disable', params=None, query_params=query_params)
+        return self._handle_request('POST', '/customer/disable', params=None, query_params=query_params, idempotency_key=idempotency_key)
+
+    @staticmethod
+    def verify_webhook_signature(payload: str, header: str, secret: str, tolerance_seconds: int = 300) -> bool:
+        """
+        Verifies a webhook payload signature received from Keymint.
+        :param payload: The raw request body as a string.
+        :param header: The value of the "Keymint-Signature" header.
+        :param secret: The webhook endpoint's signing secret.
+        :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 time
+
+        if not header or not secret:
+            return False
+
+        try:
+            # Parse header (e.g. t=1719374021,v1=signature)
+            timestamp_str = ""
+            signature = ""
+            parts = header.split(",")
+            for part in parts:
+                kv = part.strip().split("=", 1)
+                if len(kv) == 2:
+                    if kv[0] == "t":
+                        timestamp_str = kv[1]
+                    elif kv[0] == "v1":
+                        signature = kv[1]
+
+            if not timestamp_str or not signature:
+                return False
+
+            # Check timestamp validity
+            try:
+                timestamp_int = int(timestamp_str)
+            except ValueError:
+                return False
+
+            now = int(time.time())
+            if abs(now - timestamp_int) > tolerance_seconds:
+                return False
+
+            # Verify HMAC signature
+            signable_content = f"{timestamp_str}.{payload}".encode("utf-8")
+            expected_signature = hmac.new(
+                secret.encode("utf-8"),
+                signable_content,
+                hashlib.sha256
+            ).hexdigest()
+
+            # Constant-time comparison to prevent timing attacks
+            return hmac.compare_digest(expected_signature, signature)
+        except Exception:
+            return False
+
 

{keymint-2.1.1 → keymint-2.3.0}/keymint/_version.py

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

{keymint-2.1.1 → keymint-2.3.0/keymint.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keymint
-Version: 2.1.1
+Version: 2.3.0
 Summary: Official Python SDK for KeyMint license management with comprehensive API coverage.
 Home-page: https://github.com/keymint-dev/keymint-python
 Author: KeyMint
@@ -70,13 +70,13 @@ pip install keymint
 import os
 from keymint import KeyMint, identity
 
-access_token = os.environ.get('KEYMINT_ACCESS_TOKEN')
+api_key = os.environ.get('KEYMINT_API_KEY')
 product_id = os.environ.get('KEYMINT_PRODUCT_ID')
 
-if not access_token or not product_id:
-    raise ValueError('Please set the KEYMINT_ACCESS_TOKEN and KEYMINT_PRODUCT_ID environment variables.')
+if not api_key or not product_id:
+    raise ValueError('Please set the KEYMINT_API_KEY and KEYMINT_PRODUCT_ID environment variables.')
 
-sdk = KeyMint(access_token)
+sdk = KeyMint(api_key)
 
 # 1. Get a stable, unique ID for this machine
 host_id = identity.get_or_create_installation_id()
@@ -109,6 +109,9 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `get_key`        | Retrieves detailed information about a key.     |
 | `block_key`      | Blocks a license key.                           |
 | `unblock_key`    | Unblocks a previously blocked license 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.     |
 
 ### Customer Management
 
@@ -122,6 +125,22 @@ Keymint provides utilities to uniquely identify machines for node-locking:
 | `toggle_customer_status`| Toggles customer active status.                  |
 | `delete_customer`       | Permanently deletes a customer and their keys.   |
 
+### Webhook Verification
+
+| Method                  | Description                                      |
+|-------------------------|--------------------------------------------------|
+| `verify_webhook_signature`| Verifies the signature of a webhook request payload. |
+
+## Idempotency
+
+All mutating SDK methods support idempotency keys to safely retry requests in case of network drops. Pass a unique string (recommended: UUID v4) as the optional `idempotency_key` keyword argument:
+
+```python
+result = sdk.create_key({ 
+    'productId': product_id,
+}, idempotency_key='9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d')
+```
+
 ## License
 MIT
 

{keymint-2.1.1 → keymint-2.3.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="keymint",
-    version="2.1.1",
+    version="2.3.0",
     author="KeyMint",
     author_email="cliff@keymint.dev",
     description="Official Python SDK for KeyMint license management with comprehensive API coverage.",