pylicensify 1.0.0__tar.gz

pylicensify-1.0.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: pylicensify
+Version: 1.0.0
+Summary: Client SDK for PyLicense — verify software license keys with tamper-proof, signed responses.
+Author: PyLicense
+License: MIT
+Project-URL: Homepage, https://license.pyobfuscate.com
+Keywords: license,licensing,activation,drm,software-licensing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25
+Requires-Dist: cryptography>=41.0
+
+# pylicensify
+
+Client SDK for [PyLicense](https://license.pyobfuscate.com) — verify software
+license keys with **tamper-proof, signed responses**. A cracked "fake server"
+can't grant access, because every response is verified against your public key.
+
+```bash
+pip install pylicensify
+```
+
+## Quick start
+
+Get your **public key** from the dashboard → *Integration* page (safe to embed
+in your distributed app; the private key never leaves the server).
+
+```python
+from pylicensify import LicenseClient
+
+client = LicenseClient(public_key="YOUR_PUBLIC_KEY")
+
+result = client.validate("PY-XXXXXXXXXXXXXXXX")
+if result:
+    print("Licensed. Entitlements:", result.features)
+    if result.feature("pro"):
+        enable_pro_features()
+else:
+    print("Not licensed:", result.error)
+    raise SystemExit(1)
+```
+
+`validate()` sends a nonce, verifies the Ed25519 signature, and rejects stale /
+replayed responses automatically. It raises `SignatureError` on tampering and
+`NetworkError` if the server is unreachable.
+
+## Feature gating
+
+```python
+result = client.validate(key)
+seats = result.feature("seats", 1)
+if result.feature("pro"):
+    ...
+```
+
+## Offline license files (air-gapped)
+
+Issue a signed `.lic` file from a license row in the dashboard, ship it with the
+app, and verify it locally with **zero network calls**:
+
+```python
+from pylicensify import verify_offline_license
+
+data = verify_offline_license("YOUR_PUBLIC_KEY", "license.lic")
+print("Valid for:", data.get("customer"), data.get("features"))
+```
+
+Checks signature, expiry, device binding, and OS lock.
+
+## Floating / concurrent licenses
+
+For keys with a concurrent-session limit — the SDK checks out a seat, heartbeats
+in the background, and releases on exit:
+
+```python
+from pylicensify import LicenseClient, SeatUnavailable
+
+client = LicenseClient(public_key="YOUR_PUBLIC_KEY")
+try:
+    with client.session("PY-XXXX...") as sess:
+        print("Seat acquired:", sess.seats)   # {'used': 1, 'max': 5}
+        run_app()                              # released automatically on exit
+except SeatUnavailable:
+    print("All seats are in use — try again later.")
+```
+
+## Update checks
+
+```python
+info = client.check_update("PY-XXXX...", current_version="1.0.0")
+if info["update_available"]:
+    print("New version:", info["version"], info["notes"])
+    # info["download_url"] is a license-gated download link
+```
+
+## Self-hosted / custom domain
+
+```python
+client = LicenseClient(public_key="...", api_url="https://license.yourdomain.com")
+```
+
+## Hardware ID
+
+By default the SDK derives a machine id from `uuid.getnode()`. Pass your own for
+a stronger fingerprint:
+
+```python
+client.validate(key, hwid=my_custom_fingerprint())
+```
+
+## Errors
+
+| Exception | Meaning |
+|---|---|
+| `InvalidLicense` | Server rejected the key (invalid/expired/revoked/blocked) |
+| `SignatureError` | Signature/nonce/timestamp failed — forged or replayed |
+| `NetworkError` | Couldn't reach the license server |
+| `SeatUnavailable` | Floating license has no free seats |
+
+All inherit from `LicenseError`.
+
+## Hardening
+
+Obfuscate your client so the check itself can't be trivially patched out —
+e.g. with [PyObfuscate](https://pyobfuscate.com).

pylicensify-1.0.0/README.md

@@ -0,0 +1,113 @@
+# pylicensify
+
+Client SDK for [PyLicense](https://license.pyobfuscate.com) — verify software
+license keys with **tamper-proof, signed responses**. A cracked "fake server"
+can't grant access, because every response is verified against your public key.
+
+```bash
+pip install pylicensify
+```
+
+## Quick start
+
+Get your **public key** from the dashboard → *Integration* page (safe to embed
+in your distributed app; the private key never leaves the server).
+
+```python
+from pylicensify import LicenseClient
+
+client = LicenseClient(public_key="YOUR_PUBLIC_KEY")
+
+result = client.validate("PY-XXXXXXXXXXXXXXXX")
+if result:
+    print("Licensed. Entitlements:", result.features)
+    if result.feature("pro"):
+        enable_pro_features()
+else:
+    print("Not licensed:", result.error)
+    raise SystemExit(1)
+```
+
+`validate()` sends a nonce, verifies the Ed25519 signature, and rejects stale /
+replayed responses automatically. It raises `SignatureError` on tampering and
+`NetworkError` if the server is unreachable.
+
+## Feature gating
+
+```python
+result = client.validate(key)
+seats = result.feature("seats", 1)
+if result.feature("pro"):
+    ...
+```
+
+## Offline license files (air-gapped)
+
+Issue a signed `.lic` file from a license row in the dashboard, ship it with the
+app, and verify it locally with **zero network calls**:
+
+```python
+from pylicensify import verify_offline_license
+
+data = verify_offline_license("YOUR_PUBLIC_KEY", "license.lic")
+print("Valid for:", data.get("customer"), data.get("features"))
+```
+
+Checks signature, expiry, device binding, and OS lock.
+
+## Floating / concurrent licenses
+
+For keys with a concurrent-session limit — the SDK checks out a seat, heartbeats
+in the background, and releases on exit:
+
+```python
+from pylicensify import LicenseClient, SeatUnavailable
+
+client = LicenseClient(public_key="YOUR_PUBLIC_KEY")
+try:
+    with client.session("PY-XXXX...") as sess:
+        print("Seat acquired:", sess.seats)   # {'used': 1, 'max': 5}
+        run_app()                              # released automatically on exit
+except SeatUnavailable:
+    print("All seats are in use — try again later.")
+```
+
+## Update checks
+
+```python
+info = client.check_update("PY-XXXX...", current_version="1.0.0")
+if info["update_available"]:
+    print("New version:", info["version"], info["notes"])
+    # info["download_url"] is a license-gated download link
+```
+
+## Self-hosted / custom domain
+
+```python
+client = LicenseClient(public_key="...", api_url="https://license.yourdomain.com")
+```
+
+## Hardware ID
+
+By default the SDK derives a machine id from `uuid.getnode()`. Pass your own for
+a stronger fingerprint:
+
+```python
+client.validate(key, hwid=my_custom_fingerprint())
+```
+
+## Errors
+
+| Exception | Meaning |
+|---|---|
+| `InvalidLicense` | Server rejected the key (invalid/expired/revoked/blocked) |
+| `SignatureError` | Signature/nonce/timestamp failed — forged or replayed |
+| `NetworkError` | Couldn't reach the license server |
+| `SeatUnavailable` | Floating license has no free seats |
+
+All inherit from `LicenseError`.
+
+## Hardening
+
+Obfuscate your client so the check itself can't be trivially patched out —
+e.g. with [PyObfuscate](https://pyobfuscate.com).

pylicensify-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pylicensify"
+version = "1.0.0"
+description = "Client SDK for PyLicense — verify software license keys with tamper-proof, signed responses."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "PyLicense" }]
+keywords = ["license", "licensing", "activation", "drm", "software-licensing"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+dependencies = [
+  "requests>=2.25",
+  "cryptography>=41.0",
+]
+
+[project.urls]
+Homepage = "https://license.pyobfuscate.com"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pylicensify-1.0.0/setup.cfg

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

pylicensify-1.0.0/src/pylicensify/__init__.py

@@ -0,0 +1,34 @@
+"""PyLicense client SDK — verify software license keys with tamper-proof,
+signed responses.
+
+    from pylicensify import LicenseClient
+
+    client = LicenseClient(public_key="YOUR_PUBLIC_KEY")
+    result = client.validate("PY-XXXX...")
+    if result:
+        print("Licensed!", result.features)
+"""
+from .client import LicenseClient, ValidationResult, FloatingSession
+from .offline import verify_offline_license
+from ._hwid import get_hwid
+from .errors import (
+    LicenseError,
+    NetworkError,
+    InvalidLicense,
+    SignatureError,
+    SeatUnavailable,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "LicenseClient",
+    "ValidationResult",
+    "FloatingSession",
+    "verify_offline_license",
+    "get_hwid",
+    "LicenseError",
+    "NetworkError",
+    "InvalidLicense",
+    "SignatureError",
+    "SeatUnavailable",
+]

pylicensify-1.0.0/src/pylicensify/_hwid.py

@@ -0,0 +1,8 @@
+"""Hardware ID helper. Override by passing your own hwid if you need a
+stronger/OS-specific fingerprint."""
+import uuid
+
+
+def get_hwid() -> str:
+    """A stable per-machine identifier (MAC-derived). Good enough for most apps."""
+    return str(uuid.getnode())

pylicensify-1.0.0/src/pylicensify/client.py

@@ -0,0 +1,222 @@
+"""Online license validation, floating sessions, and update checks."""
+import base64
+import platform as _plat
+import secrets
+import socket
+import threading
+import time
+
+import requests
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+from cryptography.exceptions import InvalidSignature
+
+from ._hwid import get_hwid
+from .errors import NetworkError, InvalidLicense, SignatureError, SeatUnavailable
+
+DEFAULT_API = "https://license.pyobfuscate.com"
+
+
+class ValidationResult:
+    """Outcome of :meth:`LicenseClient.validate`."""
+
+    def __init__(self, valid, product_id=None, expires_at=None, features=None, raw=None, error=None):
+        self.valid = valid
+        self.product_id = product_id
+        self.expires_at = expires_at          # ISO string or None (lifetime)
+        self.features = features or {}         # signed entitlements, e.g. {"pro": True}
+        self.error = error                     # server message when not valid
+        self.raw = raw or {}
+
+    def feature(self, name, default=None):
+        return self.features.get(name, default)
+
+    def __bool__(self):
+        return self.valid
+
+    def __repr__(self):
+        return f"<ValidationResult valid={self.valid} product={self.product_id} features={self.features}>"
+
+
+class LicenseClient:
+    """Verifies license keys against a PyLicense server.
+
+    Args:
+        public_key: your account's Ed25519 public key (from the dashboard's
+            Integration page). Safe to embed in your distributed app.
+        api_url: license server base URL (defaults to the hosted platform).
+        timeout: per-request timeout in seconds.
+        max_skew: reject signed responses older than this many seconds (replay guard).
+    """
+
+    def __init__(self, public_key, api_url=DEFAULT_API, timeout=5, max_skew=300):
+        if not public_key:
+            raise ValueError("public_key is required (get it from the dashboard)")
+        self._pub = Ed25519PublicKey.from_public_bytes(base64.b64decode(public_key))
+        self.api_url = api_url.rstrip("/")
+        self.timeout = timeout
+        self.max_skew = max_skew
+
+    # ---- Online validation -------------------------------------------------
+    def validate(self, key, hwid=None, device_name=None, raise_on_invalid=False):
+        """Validate a key online and verify the signed response.
+
+        Returns a :class:`ValidationResult`. Set ``raise_on_invalid=True`` to
+        raise :class:`InvalidLicense` instead of returning ``valid=False``.
+        Always raises :class:`SignatureError` on tamper/replay and
+        :class:`NetworkError` if the server is unreachable.
+        """
+        hwid = hwid or get_hwid()
+        nonce = secrets.token_hex(8)
+        try:
+            r = requests.post(
+                f"{self.api_url}/api/v1/validate",
+                json={
+                    "key": key,
+                    "hwid": hwid,
+                    "nonce": nonce,
+                    "device_name": device_name or socket.gethostname(),
+                    "platform": f"{_plat.system()} {_plat.release()}",
+                },
+                timeout=self.timeout,
+            )
+        except requests.RequestException as e:
+            raise NetworkError(str(e))
+
+        data = r.json() if r.content else {}
+        if r.status_code != 200 or not data.get("valid"):
+            msg = data.get("error", "License is not valid")
+            if raise_on_invalid:
+                raise InvalidLicense(msg, status=r.status_code)
+            return ValidationResult(False, raw=data, error=msg)
+
+        self._verify_signature(data, hwid, nonce)
+        return ValidationResult(
+            True,
+            product_id=data.get("product_id"),
+            expires_at=data.get("expires_at"),
+            features=data.get("features"),
+            raw=data,
+        )
+
+    def _verify_signature(self, data, hwid, nonce):
+        sig = data.get("signature")
+        if not sig:
+            raise SignatureError("Response was not signed — refusing to trust it")
+        message = (
+            f"pylicense.v2|{data['product_id']}|{hwid}|"
+            f"{data.get('expires_at') or ''}|{nonce}|{data['issued_at']}|"
+            f"{data.get('features_b64', '')}"
+        )
+        try:
+            self._pub.verify(base64.b64decode(sig), message.encode())
+        except (InvalidSignature, Exception):
+            raise SignatureError("Signature verification failed — response may be forged")
+        if data.get("nonce") != nonce:
+            raise SignatureError("Nonce mismatch — possible replay")
+        if abs(time.time() - data["issued_at"]) > self.max_skew:
+            raise SignatureError("Stale response — possible replay")
+
+    # ---- Floating / concurrent sessions ------------------------------------
+    def lease(self, key, hwid=None):
+        """Reserve a concurrent seat. Returns the lease dict (lease_id, interval, seats)."""
+        hwid = hwid or get_hwid()
+        try:
+            r = requests.post(f"{self.api_url}/api/v1/lease", json={"key": key, "hwid": hwid}, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise NetworkError(str(e))
+        data = r.json() if r.content else {}
+        if r.status_code == 409:
+            raise SeatUnavailable(data.get("error", "All concurrent sessions are in use"))
+        if r.status_code != 200:
+            raise InvalidLicense(data.get("error", "Could not acquire a seat"), status=r.status_code)
+        return data
+
+    def heartbeat(self, lease_id):
+        """Keep a seat alive. Returns True if still held, False if it was released/expired."""
+        try:
+            r = requests.post(f"{self.api_url}/api/v1/heartbeat", json={"lease_id": lease_id}, timeout=self.timeout)
+        except requests.RequestException:
+            return True  # transient network blip — assume still held, retry next tick
+        return r.status_code == 200
+
+    def release(self, lease_id):
+        """Free a seat (idempotent)."""
+        try:
+            requests.post(f"{self.api_url}/api/v1/release", json={"lease_id": lease_id}, timeout=self.timeout)
+        except requests.RequestException:
+            pass
+
+    def session(self, key, hwid=None):
+        """Context manager that checks out a seat, heartbeats in the background,
+        and releases on exit::
+
+            with client.session(key):
+                run_app()
+        """
+        return FloatingSession(self, key, hwid)
+
+    # ---- Updates -----------------------------------------------------------
+    def check_update(self, key, current_version, channel="stable"):
+        """Ask whether a newer build exists. Returns the update dict
+        (update_available, version, notes, download_url, size)."""
+        try:
+            r = requests.post(
+                f"{self.api_url}/api/v1/update",
+                json={"key": key, "current_version": current_version, "channel": channel},
+                timeout=self.timeout,
+            )
+        except requests.RequestException as e:
+            raise NetworkError(str(e))
+        data = r.json() if r.content else {}
+        if r.status_code != 200:
+            raise InvalidLicense(data.get("error", "Update check failed"), status=r.status_code)
+        return data
+
+
+class FloatingSession:
+    """Holds a concurrent seat and heartbeats until released. Use via
+    :meth:`LicenseClient.session`."""
+
+    def __init__(self, client, key, hwid=None):
+        self._client = client
+        self._key = key
+        self._hwid = hwid
+        self.lease_id = None
+        self.seats = None
+        self._interval = 60
+        self._stop = threading.Event()
+        self._thread = None
+
+    def start(self):
+        data = self._client.lease(self._key, self._hwid)   # raises SeatUnavailable if full
+        self.lease_id = data["lease_id"]
+        self.seats = data.get("seats")
+        self._interval = max(15, int(data.get("interval", 60)))
+        self._thread = threading.Thread(target=self._loop, daemon=True)
+        self._thread.start()
+        return self
+
+    def _loop(self):
+        while not self._stop.wait(self._interval):
+            if not self.lease_id:
+                return
+            if not self._client.heartbeat(self.lease_id):
+                self.lease_id = None   # server released us; app can react via .active
+                return
+
+    @property
+    def active(self):
+        return self.lease_id is not None
+
+    def stop(self):
+        self._stop.set()
+        if self.lease_id:
+            self._client.release(self.lease_id)
+            self.lease_id = None
+
+    def __enter__(self):
+        return self.start()
+
+    def __exit__(self, *exc):
+        self.stop()
+        return False

pylicensify-1.0.0/src/pylicensify/errors.py

@@ -0,0 +1,25 @@
+"""Exceptions raised by the PyLicense client."""
+
+
+class LicenseError(Exception):
+    """Base class for all PyLicense errors."""
+
+
+class NetworkError(LicenseError):
+    """The license server could not be reached."""
+
+
+class InvalidLicense(LicenseError):
+    """The server rejected the license (invalid, expired, revoked, blocked...)."""
+
+    def __init__(self, message, status=None):
+        super().__init__(message)
+        self.status = status
+
+
+class SignatureError(LicenseError):
+    """Response signature/nonce/timestamp check failed — possibly forged or replayed."""
+
+
+class SeatUnavailable(LicenseError):
+    """A floating license has no free concurrent seats right now."""

pylicensify-1.0.0/src/pylicensify/offline.py

@@ -0,0 +1,62 @@
+"""Verify a signed offline ``.lic`` file with zero network calls."""
+import base64
+import json
+import time
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+from cryptography.exceptions import InvalidSignature
+
+from ._hwid import get_hwid
+from .errors import SignatureError, InvalidLicense
+
+
+def _detect_os() -> str:
+    import platform as _plat
+    s = _plat.system().lower()
+    if "win" in s:
+        return "windows"
+    if "darwin" in s or "mac" in s:
+        return "macos"
+    if "linux" in s:
+        return "linux"
+    return ""
+
+
+def verify_offline_license(public_key: str, token_or_path: str, hwid: str = None) -> dict:
+    """Verify an offline license file (or its raw token string).
+
+    Checks the Ed25519 signature, expiry, device binding, and OS lock — all
+    locally. Returns the license payload dict on success.
+
+    Raises :class:`SignatureError` if tampered, :class:`InvalidLicense` if
+    expired / wrong device / wrong OS.
+    """
+    token = token_or_path
+    # If it looks like a path, read the file; otherwise treat it as the token.
+    if "." in token_or_path and "\n" not in token_or_path and len(token_or_path) < 4096:
+        try:
+            with open(token_or_path, "r", encoding="utf-8") as f:
+                token = f.read().strip()
+        except (OSError, ValueError):
+            token = token_or_path
+
+    try:
+        payload_b64, sig_b64 = token.strip().split(".")
+        pub = Ed25519PublicKey.from_public_bytes(base64.b64decode(public_key))
+        pub.verify(base64.b64decode(sig_b64), payload_b64.encode())
+    except (InvalidSignature, ValueError, Exception):
+        raise SignatureError("Invalid or tampered license file")
+
+    data = json.loads(base64.b64decode(payload_b64))
+
+    if data.get("expires_at") and time.time() > data["expires_at"]:
+        raise InvalidLicense("License file has expired")
+
+    hwid = hwid or get_hwid()
+    if data.get("hwid") and data["hwid"] != hwid:
+        raise InvalidLicense("License file is not valid for this machine")
+
+    if data.get("os_lock") and data["os_lock"] != _detect_os():
+        raise InvalidLicense("License file is not valid on this operating system")
+
+    return data

pylicensify-1.0.0/src/pylicensify.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: pylicensify
+Version: 1.0.0
+Summary: Client SDK for PyLicense — verify software license keys with tamper-proof, signed responses.
+Author: PyLicense
+License: MIT
+Project-URL: Homepage, https://license.pyobfuscate.com
+Keywords: license,licensing,activation,drm,software-licensing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25
+Requires-Dist: cryptography>=41.0
+
+# pylicensify
+
+Client SDK for [PyLicense](https://license.pyobfuscate.com) — verify software
+license keys with **tamper-proof, signed responses**. A cracked "fake server"
+can't grant access, because every response is verified against your public key.
+
+```bash
+pip install pylicensify
+```
+
+## Quick start
+
+Get your **public key** from the dashboard → *Integration* page (safe to embed
+in your distributed app; the private key never leaves the server).
+
+```python
+from pylicensify import LicenseClient
+
+client = LicenseClient(public_key="YOUR_PUBLIC_KEY")
+
+result = client.validate("PY-XXXXXXXXXXXXXXXX")
+if result:
+    print("Licensed. Entitlements:", result.features)
+    if result.feature("pro"):
+        enable_pro_features()
+else:
+    print("Not licensed:", result.error)
+    raise SystemExit(1)
+```
+
+`validate()` sends a nonce, verifies the Ed25519 signature, and rejects stale /
+replayed responses automatically. It raises `SignatureError` on tampering and
+`NetworkError` if the server is unreachable.
+
+## Feature gating
+
+```python
+result = client.validate(key)
+seats = result.feature("seats", 1)
+if result.feature("pro"):
+    ...
+```
+
+## Offline license files (air-gapped)
+
+Issue a signed `.lic` file from a license row in the dashboard, ship it with the
+app, and verify it locally with **zero network calls**:
+
+```python
+from pylicensify import verify_offline_license
+
+data = verify_offline_license("YOUR_PUBLIC_KEY", "license.lic")
+print("Valid for:", data.get("customer"), data.get("features"))
+```
+
+Checks signature, expiry, device binding, and OS lock.
+
+## Floating / concurrent licenses
+
+For keys with a concurrent-session limit — the SDK checks out a seat, heartbeats
+in the background, and releases on exit:
+
+```python
+from pylicensify import LicenseClient, SeatUnavailable
+
+client = LicenseClient(public_key="YOUR_PUBLIC_KEY")
+try:
+    with client.session("PY-XXXX...") as sess:
+        print("Seat acquired:", sess.seats)   # {'used': 1, 'max': 5}
+        run_app()                              # released automatically on exit
+except SeatUnavailable:
+    print("All seats are in use — try again later.")
+```
+
+## Update checks
+
+```python
+info = client.check_update("PY-XXXX...", current_version="1.0.0")
+if info["update_available"]:
+    print("New version:", info["version"], info["notes"])
+    # info["download_url"] is a license-gated download link
+```
+
+## Self-hosted / custom domain
+
+```python
+client = LicenseClient(public_key="...", api_url="https://license.yourdomain.com")
+```
+
+## Hardware ID
+
+By default the SDK derives a machine id from `uuid.getnode()`. Pass your own for
+a stronger fingerprint:
+
+```python
+client.validate(key, hwid=my_custom_fingerprint())
+```
+
+## Errors
+
+| Exception | Meaning |
+|---|---|
+| `InvalidLicense` | Server rejected the key (invalid/expired/revoked/blocked) |
+| `SignatureError` | Signature/nonce/timestamp failed — forged or replayed |
+| `NetworkError` | Couldn't reach the license server |
+| `SeatUnavailable` | Floating license has no free seats |
+
+All inherit from `LicenseError`.
+
+## Hardening
+
+Obfuscate your client so the check itself can't be trivially patched out —
+e.g. with [PyObfuscate](https://pyobfuscate.com).

pylicensify-1.0.0/src/pylicensify.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/pylicensify/__init__.py
+src/pylicensify/_hwid.py
+src/pylicensify/client.py
+src/pylicensify/errors.py
+src/pylicensify/offline.py
+src/pylicensify.egg-info/PKG-INFO
+src/pylicensify.egg-info/SOURCES.txt
+src/pylicensify.egg-info/dependency_links.txt
+src/pylicensify.egg-info/requires.txt
+src/pylicensify.egg-info/top_level.txt

pylicensify-1.0.0/src/pylicensify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pylicensify-1.0.0/src/pylicensify.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25
+cryptography>=41.0

pylicensify-1.0.0/src/pylicensify.egg-info/top_level.txt

@@ -0,0 +1 @@
+pylicensify