keymint 0.1.0__tar.gz

keymint-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: keymint
+Version: 0.1.0
+Summary: A Python SDK for the KeyMint API.
+Home-page: https://github.com/keymint-dev/keymint-python
+Author: Keymint
+Author-email: admin@keymint.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# KeyMint Python SDK
+
+Welcome to the official KeyMint SDK for Python! This library provides a simple and convenient way to interact with the KeyMint API, allowing you to manage license keys for your applications with ease.
+
+## ✨ Features
+
+*   **Simple & Intuitive**: A clean and modern API that is easy to learn and use.
+*   **Type Hinting**: Uses Python's type hinting for a better developer experience.
+*   **Comprehensive**: Covers all the essential KeyMint API endpoints.
+*   **Well-Documented**: Clear and concise documentation with plenty of examples.
+*   **Error Handling**: Standardized error handling to make debugging a breeze.
+
+## 🚀 Quick Start
+
+Here's a complete example of how to use the SDK to create and activate a license key:
+
+```python
+import os
+from keymint import KeyMintSDK
+
+def main():
+    access_token = os.environ.get('KEYMINT_ACCESS_TOKEN')
+    if not access_token:
+        print('Please set the KEYMINT_ACCESS_TOKEN environment variable.')
+        return
+
+    sdk = KeyMintSDK(access_token)
+
+    try:
+        # 1. Create a new license key
+        create_response = sdk.create_key({
+            'productId': 'YOUR_PRODUCT_ID',
+        })
+        license_key = create_response['key']
+        print(f'Key created: {license_key}')
+
+        # 2. Activate the license key
+        activate_response = sdk.activate_key({
+            'productId': 'YOUR_PRODUCT_ID',
+            'licenseKey': license_key,
+            'hostId': 'UNIQUE_DEVICE_ID',
+        })
+        print(f"Key activated: {activate_response['message']}")
+    except Exception as e:
+        print(f'An error occurred: {e}')
+
+if __name__ == '__main__':
+    main()
+```
+
+## 📦 Installation
+
+```bash
+pip install keymint
+```
+
+## 🛠️ Usage
+
+### Initialization
+
+First, import the `KeyMintSDK` and initialize it with your access token. You can find your access token in your [KeyMint dashboard](https://keymint.dev/app/settings/api).
+
+```python
+from keymint import KeyMintSDK
+
+access_token = 'YOUR_ACCESS_TOKEN'
+sdk = KeyMintSDK(access_token)
+```
+
+### API Methods
+
+All methods return a dictionary.
+
+| Method          | Description                                     |
+| --------------- | ----------------------------------------------- |
+| `create_key`    | Creates a new license key.                      |
+| `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.     |
+| `block_key`     | Blocks a license key.                           |
+| `unblock_key`   | Unblocks a previously blocked license key.      |
+
+For more detailed information about the API methods and their parameters, please refer to the [API Reference](#api-reference) section below.
+
+## 🚨 Error Handling
+
+If an API call fails, the SDK will raise a `KeyMintApiError` exception. This object contains a `message`, `code`, and `status` attribute that you can use to handle the error.
+
+```python
+from keymint import KeyMintApiError
+
+try:
+    # ...
+except KeyMintApiError as e:
+    print(f'API Error: {e.message}')
+    print(f'Status: {e.status}')
+    print(f'Code: {e.code}')
+except Exception as e:
+    print(f'An unexpected error occurred: {e}')
+```
+
+## 📚 API Reference
+
+### `KeyMintSDK(access_token, base_url)`
+
+| Parameter      | Type     | Description                                                                 |
+| -------------- | -------- | --------------------------------------------------------------------------- |
+| `access_token` | `str`    | **Required.** Your KeyMint API access token.                                |
+| `base_url`     | `str`    | *Optional.* The base URL for the KeyMint API. Defaults to `https://api.keymint.dev`. |
+
+### `create_key(params)`
+
+| Parameter        | Type     | Description                                                                 |
+| ---------------- | -------- | --------------------------------------------------------------------------- |
+| `productId`      | `str`    | **Required.** The ID of the product.                                        |
+| `maxActivations` | `str`    | *Optional.* The maximum number of activations for the key.                  |
+| `expiryDate`     | `str`    | *Optional.* The expiration date of the key in ISO 8601 format.              |
+| `customerId`     | `str`    | *Optional.* The ID of an existing customer to associate with the key.       |
+| `newCustomer`    | `dict`   | *Optional.* A dictionary containing the name and email of a new customer.   |
+
+### `activate_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to activate.                                  |
+| `hostId`     | `str`    | *Optional.* A unique identifier for the device.                             |
+| `deviceTag`  | `str`    | *Optional.* A user-friendly name for the device.                            |
+
+### `deactivate_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to deactivate.                                |
+| `hostId`     | `str`    | *Optional.* The ID of the device to deactivate. If omitted, all devices are deactivated. |
+
+### `get_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to retrieve.                                  |
+
+### `block_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to block.                                     |
+
+### `unblock_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to unblock.                                   |
+
+## 📜 License
+
+This SDK is licensed under the MIT License.

keymint-0.1.0/README.md

@@ -0,0 +1,161 @@
+# KeyMint Python SDK
+
+Welcome to the official KeyMint SDK for Python! This library provides a simple and convenient way to interact with the KeyMint API, allowing you to manage license keys for your applications with ease.
+
+## ✨ Features
+
+*   **Simple & Intuitive**: A clean and modern API that is easy to learn and use.
+*   **Type Hinting**: Uses Python's type hinting for a better developer experience.
+*   **Comprehensive**: Covers all the essential KeyMint API endpoints.
+*   **Well-Documented**: Clear and concise documentation with plenty of examples.
+*   **Error Handling**: Standardized error handling to make debugging a breeze.
+
+## 🚀 Quick Start
+
+Here's a complete example of how to use the SDK to create and activate a license key:
+
+```python
+import os
+from keymint import KeyMintSDK
+
+def main():
+    access_token = os.environ.get('KEYMINT_ACCESS_TOKEN')
+    if not access_token:
+        print('Please set the KEYMINT_ACCESS_TOKEN environment variable.')
+        return
+
+    sdk = KeyMintSDK(access_token)
+
+    try:
+        # 1. Create a new license key
+        create_response = sdk.create_key({
+            'productId': 'YOUR_PRODUCT_ID',
+        })
+        license_key = create_response['key']
+        print(f'Key created: {license_key}')
+
+        # 2. Activate the license key
+        activate_response = sdk.activate_key({
+            'productId': 'YOUR_PRODUCT_ID',
+            'licenseKey': license_key,
+            'hostId': 'UNIQUE_DEVICE_ID',
+        })
+        print(f"Key activated: {activate_response['message']}")
+    except Exception as e:
+        print(f'An error occurred: {e}')
+
+if __name__ == '__main__':
+    main()
+```
+
+## 📦 Installation
+
+```bash
+pip install keymint
+```
+
+## 🛠️ Usage
+
+### Initialization
+
+First, import the `KeyMintSDK` and initialize it with your access token. You can find your access token in your [KeyMint dashboard](https://keymint.dev/app/settings/api).
+
+```python
+from keymint import KeyMintSDK
+
+access_token = 'YOUR_ACCESS_TOKEN'
+sdk = KeyMintSDK(access_token)
+```
+
+### API Methods
+
+All methods return a dictionary.
+
+| Method          | Description                                     |
+| --------------- | ----------------------------------------------- |
+| `create_key`    | Creates a new license key.                      |
+| `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.     |
+| `block_key`     | Blocks a license key.                           |
+| `unblock_key`   | Unblocks a previously blocked license key.      |
+
+For more detailed information about the API methods and their parameters, please refer to the [API Reference](#api-reference) section below.
+
+## 🚨 Error Handling
+
+If an API call fails, the SDK will raise a `KeyMintApiError` exception. This object contains a `message`, `code`, and `status` attribute that you can use to handle the error.
+
+```python
+from keymint import KeyMintApiError
+
+try:
+    # ...
+except KeyMintApiError as e:
+    print(f'API Error: {e.message}')
+    print(f'Status: {e.status}')
+    print(f'Code: {e.code}')
+except Exception as e:
+    print(f'An unexpected error occurred: {e}')
+```
+
+## 📚 API Reference
+
+### `KeyMintSDK(access_token, base_url)`
+
+| Parameter      | Type     | Description                                                                 |
+| -------------- | -------- | --------------------------------------------------------------------------- |
+| `access_token` | `str`    | **Required.** Your KeyMint API access token.                                |
+| `base_url`     | `str`    | *Optional.* The base URL for the KeyMint API. Defaults to `https://api.keymint.dev`. |
+
+### `create_key(params)`
+
+| Parameter        | Type     | Description                                                                 |
+| ---------------- | -------- | --------------------------------------------------------------------------- |
+| `productId`      | `str`    | **Required.** The ID of the product.                                        |
+| `maxActivations` | `str`    | *Optional.* The maximum number of activations for the key.                  |
+| `expiryDate`     | `str`    | *Optional.* The expiration date of the key in ISO 8601 format.              |
+| `customerId`     | `str`    | *Optional.* The ID of an existing customer to associate with the key.       |
+| `newCustomer`    | `dict`   | *Optional.* A dictionary containing the name and email of a new customer.   |
+
+### `activate_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to activate.                                  |
+| `hostId`     | `str`    | *Optional.* A unique identifier for the device.                             |
+| `deviceTag`  | `str`    | *Optional.* A user-friendly name for the device.                            |
+
+### `deactivate_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to deactivate.                                |
+| `hostId`     | `str`    | *Optional.* The ID of the device to deactivate. If omitted, all devices are deactivated. |
+
+### `get_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to retrieve.                                  |
+
+### `block_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to block.                                     |
+
+### `unblock_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to unblock.                                   |
+
+## 📜 License
+
+This SDK is licensed under the MIT License.

keymint-0.1.0/keymint/__init__.py

@@ -0,0 +1,85 @@
+import requests
+from .types import *
+
+class KeyMintSDK:
+    def __init__(self, access_token: str, base_url: str = "https://api.keymint.dev"):
+        if not access_token:
+            raise ValueError("Access token is required to initialize the SDK.")
+        
+        self.access_token = access_token
+        self.base_url = base_url
+        self.headers = {
+            'Authorization': f'Bearer {self.access_token}',
+            'Content-Type': 'application/json'
+        }
+
+    def _handle_request(self, endpoint: str, params: dict):
+        url = f'{self.base_url}{endpoint}'
+        try:
+            response = requests.post(url, json=params, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as http_err:
+            try:
+                error_data = http_err.response.json()
+                raise KeyMintApiError(
+                    message=error_data.get('message', 'An API error occurred'),
+                    code=error_data.get('code', -1),
+                    status=http_err.response.status_code
+                )
+            except ValueError:
+                raise KeyMintApiError(
+                    message=str(http_err),
+                    code=-1,
+                    status=http_err.response.status_code
+                )
+        except Exception as err:
+            raise KeyMintApiError(message=str(err), code=-1)
+
+    def create_key(self, params: CreateKeyParams) -> CreateKeyResponse:
+        """
+        Creates a new license key.
+        :param params: Parameters for creating the key.
+        :returns: The created key information.
+        """
+        return self._handle_request('/create-key', params)
+
+    def activate_key(self, params: ActivateKeyParams) -> ActivateKeyResponse:
+        """
+        Activates a license key for a specific device.
+        :param params: Parameters for activating the key.
+        :returns: The activation status.
+        """
+        return self._handle_request('/activate-key', params)
+
+    def deactivate_key(self, params: DeactivateKeyParams) -> DeactivateKeyResponse:
+        """
+        Deactivates a device from a license key.
+        :param params: Parameters for deactivating the key.
+        :returns: The deactivation confirmation.
+        """
+        return self._handle_request('/deactivate-key', params)
+
+    def get_key(self, params: GetKeyParams) -> GetKeyResponse:
+        """
+        Retrieves detailed information about a specific license key.
+        :param params: Parameters for fetching the key details.
+        :returns: The license key details.
+        """
+        return self._handle_request('/get-key', params)
+
+    def block_key(self, params: BlockKeyParams) -> BlockKeyResponse:
+        """
+        Blocks a specific license key.
+        :param params: Parameters for blocking the key.
+        :returns: The block confirmation.
+        """
+        return self._handle_request('/block-key', params)
+
+    def unblock_key(self, params: UnblockKeyParams) -> UnblockKeyResponse:
+        """
+        Unblocks a previously blocked license key.
+        :param params: Parameters for unblocking the key.
+        :returns: The unblock confirmation.
+        """
+        return self._handle_request('/unblock-key', params)

keymint-0.1.0/keymint/types.py

@@ -0,0 +1,90 @@
+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]
+    newCustomer: Optional[NewCustomer]
+
+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
+    licensee_name: Optional[str]
+    licensee_email: Optional[str]
+
+class DeactivateKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+    hostId: Optional[str]
+
+class DeactivateKeyResponse(TypedDict):
+    message: str
+    code: int
+
+class DeviceDetails(TypedDict):
+    host_id: str
+    device_tag: Optional[str]
+    ip_address: Optional[str]
+    activation_time: str
+
+class LicenseDetails(TypedDict):
+    id: str
+    key: str
+    product_id: str
+    max_activations: int
+    activations: int
+    devices: List[DeviceDetails]
+    activated: bool
+    expiration_date: Optional[str]
+
+class CustomerDetails(TypedDict):
+    id: str
+    name: Optional[str]
+    email: Optional[str]
+    active: bool
+
+class GetKeyParams(TypedDict):
+    productId: str
+    licenseKey: str
+
+class GetKeyResponse(TypedDict):
+    code: int
+    data: Dict[str, Any]
+
+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

keymint-0.1.0/keymint.egg-info/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: keymint
+Version: 0.1.0
+Summary: A Python SDK for the KeyMint API.
+Home-page: https://github.com/keymint-dev/keymint-python
+Author: Keymint
+Author-email: admin@keymint.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# KeyMint Python SDK
+
+Welcome to the official KeyMint SDK for Python! This library provides a simple and convenient way to interact with the KeyMint API, allowing you to manage license keys for your applications with ease.
+
+## ✨ Features
+
+*   **Simple & Intuitive**: A clean and modern API that is easy to learn and use.
+*   **Type Hinting**: Uses Python's type hinting for a better developer experience.
+*   **Comprehensive**: Covers all the essential KeyMint API endpoints.
+*   **Well-Documented**: Clear and concise documentation with plenty of examples.
+*   **Error Handling**: Standardized error handling to make debugging a breeze.
+
+## 🚀 Quick Start
+
+Here's a complete example of how to use the SDK to create and activate a license key:
+
+```python
+import os
+from keymint import KeyMintSDK
+
+def main():
+    access_token = os.environ.get('KEYMINT_ACCESS_TOKEN')
+    if not access_token:
+        print('Please set the KEYMINT_ACCESS_TOKEN environment variable.')
+        return
+
+    sdk = KeyMintSDK(access_token)
+
+    try:
+        # 1. Create a new license key
+        create_response = sdk.create_key({
+            'productId': 'YOUR_PRODUCT_ID',
+        })
+        license_key = create_response['key']
+        print(f'Key created: {license_key}')
+
+        # 2. Activate the license key
+        activate_response = sdk.activate_key({
+            'productId': 'YOUR_PRODUCT_ID',
+            'licenseKey': license_key,
+            'hostId': 'UNIQUE_DEVICE_ID',
+        })
+        print(f"Key activated: {activate_response['message']}")
+    except Exception as e:
+        print(f'An error occurred: {e}')
+
+if __name__ == '__main__':
+    main()
+```
+
+## 📦 Installation
+
+```bash
+pip install keymint
+```
+
+## 🛠️ Usage
+
+### Initialization
+
+First, import the `KeyMintSDK` and initialize it with your access token. You can find your access token in your [KeyMint dashboard](https://keymint.dev/app/settings/api).
+
+```python
+from keymint import KeyMintSDK
+
+access_token = 'YOUR_ACCESS_TOKEN'
+sdk = KeyMintSDK(access_token)
+```
+
+### API Methods
+
+All methods return a dictionary.
+
+| Method          | Description                                     |
+| --------------- | ----------------------------------------------- |
+| `create_key`    | Creates a new license key.                      |
+| `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.     |
+| `block_key`     | Blocks a license key.                           |
+| `unblock_key`   | Unblocks a previously blocked license key.      |
+
+For more detailed information about the API methods and their parameters, please refer to the [API Reference](#api-reference) section below.
+
+## 🚨 Error Handling
+
+If an API call fails, the SDK will raise a `KeyMintApiError` exception. This object contains a `message`, `code`, and `status` attribute that you can use to handle the error.
+
+```python
+from keymint import KeyMintApiError
+
+try:
+    # ...
+except KeyMintApiError as e:
+    print(f'API Error: {e.message}')
+    print(f'Status: {e.status}')
+    print(f'Code: {e.code}')
+except Exception as e:
+    print(f'An unexpected error occurred: {e}')
+```
+
+## 📚 API Reference
+
+### `KeyMintSDK(access_token, base_url)`
+
+| Parameter      | Type     | Description                                                                 |
+| -------------- | -------- | --------------------------------------------------------------------------- |
+| `access_token` | `str`    | **Required.** Your KeyMint API access token.                                |
+| `base_url`     | `str`    | *Optional.* The base URL for the KeyMint API. Defaults to `https://api.keymint.dev`. |
+
+### `create_key(params)`
+
+| Parameter        | Type     | Description                                                                 |
+| ---------------- | -------- | --------------------------------------------------------------------------- |
+| `productId`      | `str`    | **Required.** The ID of the product.                                        |
+| `maxActivations` | `str`    | *Optional.* The maximum number of activations for the key.                  |
+| `expiryDate`     | `str`    | *Optional.* The expiration date of the key in ISO 8601 format.              |
+| `customerId`     | `str`    | *Optional.* The ID of an existing customer to associate with the key.       |
+| `newCustomer`    | `dict`   | *Optional.* A dictionary containing the name and email of a new customer.   |
+
+### `activate_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to activate.                                  |
+| `hostId`     | `str`    | *Optional.* A unique identifier for the device.                             |
+| `deviceTag`  | `str`    | *Optional.* A user-friendly name for the device.                            |
+
+### `deactivate_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to deactivate.                                |
+| `hostId`     | `str`    | *Optional.* The ID of the device to deactivate. If omitted, all devices are deactivated. |
+
+### `get_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to retrieve.                                  |
+
+### `block_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to block.                                     |
+
+### `unblock_key(params)`
+
+| Parameter    | Type     | Description                                                                 |
+| ------------ | -------- | --------------------------------------------------------------------------- |
+| `productId`  | `str`    | **Required.** The ID of the product.                                        |
+| `licenseKey` | `str`    | **Required.** The license key to unblock.                                   |
+
+## 📜 License
+
+This SDK is licensed under the MIT License.

keymint-0.1.0/keymint.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+keymint/__init__.py
+keymint/types.py
+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
+tests/test_keymint.py

keymint-0.1.0/keymint.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

keymint-0.1.0/keymint.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

keymint-0.1.0/keymint.egg-info/top_level.txt

@@ -0,0 +1 @@
+keymint

keymint-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

keymint-0.1.0/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="keymint",
+    version="0.1.0",
+    author="Keymint",
+    author_email="admin@keymint.dev",
+    description="A Python SDK for the KeyMint API.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/keymint-dev/keymint-python",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+        'requests',
+    ],
+)

keymint-0.1.0/tests/test_keymint.py

@@ -0,0 +1,104 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import requests
+from keymint import KeyMintSDK, KeyMintApiError
+from keymint.types import *
+
+class TestKeyMintSDK(unittest.TestCase):
+
+    def setUp(self):
+        self.sdk = KeyMintSDK(access_token="test_token")
+
+    @patch('requests.post')
+    def test_create_key_success(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'code': 0, 'key': 'test_key'}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        params: CreateKeyParams = {'productId': 'prod_123'}
+        response = self.sdk.create_key(params)
+
+        self.assertEqual(response['key'], 'test_key')
+        mock_post.assert_called_once()
+
+    @patch('requests.post')
+    def test_create_key_failure(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'message': 'Error', 'code': 1}
+        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(response=mock_response)
+        mock_post.return_value = mock_response
+
+        params: CreateKeyParams = {'productId': 'prod_123'}
+        with self.assertRaises(KeyMintApiError) as context:
+            self.sdk.create_key(params)
+        
+        self.assertEqual(context.exception.code, 1)
+
+    @patch('requests.post')
+    def test_activate_key_success(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'code': 0, 'message': 'activated'}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        params: ActivateKeyParams = {'productId': 'prod_123', 'licenseKey': 'key_123'}
+        response = self.sdk.activate_key(params)
+
+        self.assertEqual(response['message'], 'activated')
+        mock_post.assert_called_once()
+
+    @patch('requests.post')
+    def test_deactivate_key_success(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'code': 0, 'message': 'deactivated'}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        params: DeactivateKeyParams = {'productId': 'prod_123', 'licenseKey': 'key_123'}
+        response = self.sdk.deactivate_key(params)
+
+        self.assertEqual(response['message'], 'deactivated')
+        mock_post.assert_called_once()
+
+    @patch('requests.post')
+    def test_get_key_success(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'code': 0, 'data': {'license': {}}}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        params: GetKeyParams = {'productId': 'prod_123', 'licenseKey': 'key_123'}
+        response = self.sdk.get_key(params)
+
+        self.assertIn('license', response['data'])
+        mock_post.assert_called_once()
+
+    @patch('requests.post')
+    def test_block_key_success(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'code': 0, 'message': 'blocked'}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        params: BlockKeyParams = {'productId': 'prod_123', 'licenseKey': 'key_123'}
+        response = self.sdk.block_key(params)
+
+        self.assertEqual(response['message'], 'blocked')
+        mock_post.assert_called_once()
+
+    @patch('requests.post')
+    def test_unblock_key_success(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'code': 0, 'message': 'unblocked'}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        params: UnblockKeyParams = {'productId': 'prod_123', 'licenseKey': 'key_123'}
+        response = self.sdk.unblock_key(params)
+
+        self.assertEqual(response['message'], 'unblocked')
+        mock_post.assert_called_once()
+
+if __name__ == '__main__':
+    unittest.main()