keywarden 1.0.0__tar.gz

keywarden-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Key-Warden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

keywarden-1.0.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: keywarden
+Version: 1.0.0
+Summary: Official Python client for Key-Warden - validate software licences online (seat- and revocation-aware) or verify signed tokens offline against your embedded public key.
+Author: Key-Warden
+License: MIT
+Project-URL: Homepage, https://key-warden.com
+Project-URL: Documentation, https://key-warden.com/docs
+Project-URL: Issues, https://key-warden.com/contact
+Keywords: key-warden,keywarden,licence,license,licensing,activation,software-licensing,ed25519,offline-verification
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=3.4
+Dynamic: license-file
+
+# keywarden
+
+The official Python client for [Key-Warden](https://key-warden.com). Validate a
+software licence online — seat-aware, revocation-aware — or verify a signed token
+offline against your embedded public key, with no network round-trip.
+
+One dependency: [`cryptography`](https://pypi.org/project/cryptography/) (for
+Ed25519). Networking is stdlib `urllib`. Python 3.8+.
+
+```bash
+pip install keywarden
+```
+
+## Validate online
+
+The authoritative check. Ask the platform whether a licence is good *right now*.
+
+```python
+import os, socket
+import keywarden as kw
+
+res = kw.validate(
+    customer_licence_key,
+    apim_key=os.environ["KW_APIM_KEY"],      # your APIM subscription key
+    client_key=os.environ["KW_CLIENT_KEY"],  # your validation key
+    machine_id=kw.machine_id_from(socket.gethostname(), user_id),  # stable, hashed your side
+)
+
+if not res["valid"]:
+    raise SystemExit(f"licence not valid: {res.get('reason')}")
+# res["token"] is a freshly signed proof — cache it for the offline path below.
+```
+
+A `valid == False` (e.g. `revoked`, `expired`, `seat_limit_exceeded`) is **data**,
+not an error. A wrong `client_key` raises a `KeyWardenError` with
+`code == "unauthorized_client"` — that's *your* auth failing, and your customer
+should never see it as a licence problem.
+
+## Verify offline
+
+No connection? Verify a token you already hold against your **public** key —
+the 32-byte raw key from your vendor console. Pure, no network.
+
+```python
+check = kw.verify_token(cached_token, os.environ["KW_PUBLIC_KEY"])
+if not check["valid"]:
+    lock_features(check["reason"])  # "bad_signature" | "expired" | ...
+```
+
+The token is `header.body.signature` (compact JWT style) and the Ed25519
+signature covers the exact bytes `header.body`. This client verifies over those
+bytes — it never decodes-then-reverifies, which is the one mistake that silently
+breaks offline checks. Expiry is honoured within the offline grace window you set
+at mint time.
+
+## Online, with an offline fallback
+
+The pattern most desktop apps want: online is authoritative; if the network is
+down, keep working within grace.
+
+```python
+res = kw.validate_or_verify(
+    customer_licence_key,
+    apim_key=apim_key, client_key=client_key, machine_id=machine_id,
+    cached_token=last_good_token,            # from a previous validate()
+    public_key=os.environ["KW_PUBLIC_KEY"],
+)
+# res["source"] == "online" | "offline"
+```
+
+A rejected `client_key` (401) is never masked by the offline path — only a genuine
+reachability failure falls back.
+
+## API
+
+| Function | Purpose |
+|---|---|
+| `validate(key, *, apim_key, client_key, ...)` | Online check. Returns `{"valid", "reason"?, "activeSeats"?, "token"?}`. |
+| `verify_token(token, raw_pub_b64, *, now=None)` | Offline check. Returns `{"valid", "reason"?, "claims"?}`. |
+| `validate_or_verify(key, *, cached_token, public_key, ...)` | Online, falling back to a cached token when unreachable. |
+| `machine_id_from(*parts)` | A stable SHA-256 machine id; raw parts never leave the machine. |
+
+Any real failure (bad credentials, unreachable gateway, server error) raises
+`KeyWardenError`, which carries `.code` and `.status`.
+
+## Security notes
+
+- Your **private** signing key never leaves Key-Warden's Key Vault. You embed
+  only the 32-byte public half.
+- `machine_id` is hashed by the platform, but send an opaque, stable id — not a
+  raw MAC address or a hostname you wouldn't want logged. `machine_id_from()`
+  hashes on your side too.
+- Two independent credentials gate every online call: the APIM subscription key
+  gets you to the gateway, the validation key authenticates you as the vendor. A
+  leaked validation key can be rotated without reissuing a single customer
+  licence.
+
+## Licence
+
+MIT.

keywarden-1.0.0/README.md

@@ -0,0 +1,100 @@
+# keywarden
+
+The official Python client for [Key-Warden](https://key-warden.com). Validate a
+software licence online — seat-aware, revocation-aware — or verify a signed token
+offline against your embedded public key, with no network round-trip.
+
+One dependency: [`cryptography`](https://pypi.org/project/cryptography/) (for
+Ed25519). Networking is stdlib `urllib`. Python 3.8+.
+
+```bash
+pip install keywarden
+```
+
+## Validate online
+
+The authoritative check. Ask the platform whether a licence is good *right now*.
+
+```python
+import os, socket
+import keywarden as kw
+
+res = kw.validate(
+    customer_licence_key,
+    apim_key=os.environ["KW_APIM_KEY"],      # your APIM subscription key
+    client_key=os.environ["KW_CLIENT_KEY"],  # your validation key
+    machine_id=kw.machine_id_from(socket.gethostname(), user_id),  # stable, hashed your side
+)
+
+if not res["valid"]:
+    raise SystemExit(f"licence not valid: {res.get('reason')}")
+# res["token"] is a freshly signed proof — cache it for the offline path below.
+```
+
+A `valid == False` (e.g. `revoked`, `expired`, `seat_limit_exceeded`) is **data**,
+not an error. A wrong `client_key` raises a `KeyWardenError` with
+`code == "unauthorized_client"` — that's *your* auth failing, and your customer
+should never see it as a licence problem.
+
+## Verify offline
+
+No connection? Verify a token you already hold against your **public** key —
+the 32-byte raw key from your vendor console. Pure, no network.
+
+```python
+check = kw.verify_token(cached_token, os.environ["KW_PUBLIC_KEY"])
+if not check["valid"]:
+    lock_features(check["reason"])  # "bad_signature" | "expired" | ...
+```
+
+The token is `header.body.signature` (compact JWT style) and the Ed25519
+signature covers the exact bytes `header.body`. This client verifies over those
+bytes — it never decodes-then-reverifies, which is the one mistake that silently
+breaks offline checks. Expiry is honoured within the offline grace window you set
+at mint time.
+
+## Online, with an offline fallback
+
+The pattern most desktop apps want: online is authoritative; if the network is
+down, keep working within grace.
+
+```python
+res = kw.validate_or_verify(
+    customer_licence_key,
+    apim_key=apim_key, client_key=client_key, machine_id=machine_id,
+    cached_token=last_good_token,            # from a previous validate()
+    public_key=os.environ["KW_PUBLIC_KEY"],
+)
+# res["source"] == "online" | "offline"
+```
+
+A rejected `client_key` (401) is never masked by the offline path — only a genuine
+reachability failure falls back.
+
+## API
+
+| Function | Purpose |
+|---|---|
+| `validate(key, *, apim_key, client_key, ...)` | Online check. Returns `{"valid", "reason"?, "activeSeats"?, "token"?}`. |
+| `verify_token(token, raw_pub_b64, *, now=None)` | Offline check. Returns `{"valid", "reason"?, "claims"?}`. |
+| `validate_or_verify(key, *, cached_token, public_key, ...)` | Online, falling back to a cached token when unreachable. |
+| `machine_id_from(*parts)` | A stable SHA-256 machine id; raw parts never leave the machine. |
+
+Any real failure (bad credentials, unreachable gateway, server error) raises
+`KeyWardenError`, which carries `.code` and `.status`.
+
+## Security notes
+
+- Your **private** signing key never leaves Key-Warden's Key Vault. You embed
+  only the 32-byte public half.
+- `machine_id` is hashed by the platform, but send an opaque, stable id — not a
+  raw MAC address or a hostname you wouldn't want logged. `machine_id_from()`
+  hashes on your side too.
+- Two independent credentials gate every online call: the APIM subscription key
+  gets you to the gateway, the validation key authenticates you as the vendor. A
+  leaked validation key can be rotated without reissuing a single customer
+  licence.
+
+## Licence
+
+MIT.

keywarden-1.0.0/keywarden/__init__.py

@@ -0,0 +1,232 @@
+"""
+keywarden - the official Python client for Key-Warden.
+
+Two things, and only two, because that is all a vendor needs:
+
+    validate(key, ...)        the ONLINE check. Asks the platform whether a
+                              licence is good right now: seat-aware,
+                              revocation-aware, expiry-aware. Returns a fresh
+                              signed token you can cache.
+
+    verify_token(token, pub)  the OFFLINE check. Verifies a token you already
+                              hold against your embedded public key, with no
+                              network round trip at all.
+
+The token is a compact JWT-style envelope, ``header.body.signature``, each part
+base64url, the Ed25519 signature computed over the exact bytes ``header.body``.
+This client verifies over those exact bytes - it does NOT decode-then-reverify,
+because the one thing everyone gets wrong is signing the decoded JSON instead of
+the encoded string.
+
+Only dependency: ``cryptography`` (for Ed25519). Networking is stdlib urllib.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Callable, Dict, Optional
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+__all__ = [
+    "validate",
+    "verify_token",
+    "validate_or_verify",
+    "machine_id_from",
+    "KeyWardenError",
+    "DEFAULT_BASE",
+]
+
+__version__ = "1.0.0"
+
+DEFAULT_BASE = "https://api.key-warden.com"
+_VALIDATE_PATH = "/keywarden/validate"
+
+
+class KeyWardenError(Exception):
+    """A problem with the request or the vendor's own auth - NOT a licence verdict.
+
+    A licence that is simply not valid comes back as ``{"valid": False, ...}``;
+    only real failures (bad credentials, unreachable gateway, server error) raise.
+    """
+
+    def __init__(self, message: str, code: str, status: Optional[int] = None):
+        super().__init__(message)
+        self.code = code
+        self.status = status
+
+
+def _b64url_to_bytes(s: str) -> bytes:
+    s = str(s).replace("-", "+").replace("_", "/")
+    return base64.b64decode(s + "=" * (-len(s) % 4))
+
+
+def verify_token(token: str, raw_pub_b64: str, *, now: Optional[int] = None) -> Dict[str, Any]:
+    """OFFLINE verification. Pure, no network.
+
+    :param token: ``header.body.signature`` as returned by :func:`validate`.
+    :param raw_pub_b64: your vendor public key, the 32 raw bytes, base64.
+    :param now: unix seconds; for testing. Defaults to real time.
+    :returns: ``{"valid": bool, "reason": str?, "claims": dict?}``
+    """
+    parts = str(token or "").split(".")
+    if len(parts) != 3:
+        return {"valid": False, "reason": "malformed_token"}
+    header, body, sig = parts
+
+    try:
+        raw = base64.b64decode(str(raw_pub_b64 or ""))
+    except Exception:
+        return {"valid": False, "reason": "bad_public_key"}
+    if len(raw) != 32:
+        # The vendor console hands out the raw 32-byte key; a PEM or an SPKI blob
+        # will be the wrong length, and that is a configuration mistake worth
+        # naming rather than a silent failure.
+        return {"valid": False, "reason": "bad_public_key"}
+
+    try:
+        pub = Ed25519PublicKey.from_public_bytes(raw)
+    except Exception:
+        return {"valid": False, "reason": "bad_public_key"}
+
+    # The signature covers the STRING "header.body" exactly as transmitted -
+    # not the decoded claims. Verify over those bytes and nothing else.
+    try:
+        pub.verify(_b64url_to_bytes(sig), f"{header}.{body}".encode("ascii"))
+    except (InvalidSignature, Exception):
+        return {"valid": False, "reason": "bad_signature"}
+
+    try:
+        claims = json.loads(_b64url_to_bytes(body).decode("utf-8"))
+    except Exception:
+        return {"valid": False, "reason": "bad_claims"}
+
+    # Expiry is checked WITHIN the offline grace window set at mint time.
+    at = int(now) if now is not None else int(time.time())
+    grace_days = float(claims.get("grace_seconds", 0)) / 86400.0
+    exp = claims.get("exp")
+    if exp and at > int(exp) + grace_days * 86400:
+        return {"valid": False, "reason": "expired", "claims": claims}
+
+    # A signed NEGATIVE (valid:false) is a proof of revocation and is honoured.
+    if claims.get("valid") is False:
+        return {"valid": False, "reason": claims.get("reason", "not_valid"), "claims": claims}
+
+    return {"valid": True, "claims": claims}
+
+
+def validate(
+    key: str,
+    *,
+    apim_key: Optional[str] = None,
+    client_key: Optional[str] = None,
+    machine_id: Optional[str] = None,
+    base_url: str = DEFAULT_BASE,
+    timeout: float = 15.0,
+    opener: Optional[Callable[..., Any]] = None,
+) -> Dict[str, Any]:
+    """ONLINE validation against the gateway.
+
+    :param key: the customer's activation key.
+    :param apim_key: your APIM subscription key (gets you to the gateway).
+    :param client_key: your validation key (authenticates you as the vendor).
+    :param machine_id: a stable per-install id; required for node-locked
+        licences. Only a one-way hash ever leaves this machine.
+    :param opener: an injectable ``urlopen``-compatible callable, for tests.
+    :returns: the gateway JSON, e.g. ``{"valid": True, "activeSeats": 4, "token": "..."}``.
+    :raises KeyWardenError: on missing credentials, a rejected validation key
+        (401), an unreachable gateway, or a server error.
+    """
+    if not key or not isinstance(key, str):
+        raise KeyWardenError("validate(key, ...): key must be a non-empty string", "missing_key")
+    if not apim_key:
+        raise KeyWardenError("apim_key is required (your APIM subscription key)", "missing_apim_key")
+    if not client_key:
+        raise KeyWardenError("client_key is required (your validation key)", "missing_client_key")
+
+    url = base_url.rstrip("/") + _VALIDATE_PATH
+    payload = {"key": key, "machineId": machine_id} if machine_id else {"key": key}
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=data, method="POST")
+    req.add_header("Content-Type", "application/json")
+    req.add_header("Ocp-Apim-Subscription-Key", apim_key)
+    req.add_header("X-Client-Key", client_key)
+    # The raw machine id never leaves the caller untouched-but-unhashed by the
+    # platform; sending an opaque, stable id (not a MAC address) is the caller's
+    # job. machine_id_from() helps.
+    if machine_id:
+        req.add_header("X-Machine-Id", str(machine_id))
+
+    _open = opener or urllib.request.urlopen
+    try:
+        resp = _open(req, timeout=timeout)
+        status = getattr(resp, "status", None) or resp.getcode()
+        raw = resp.read()
+    except urllib.error.HTTPError as e:  # noqa: PERF203 - explicit branches read better
+        status = e.code
+        raw = e.read()
+    except urllib.error.URLError as e:
+        raise KeyWardenError(f"could not reach the gateway: {e.reason}", "unreachable") from e
+    except TimeoutError as e:
+        raise KeyWardenError(f"validation timed out after {timeout}s", "timeout") from e
+
+    try:
+        body = json.loads(raw.decode("utf-8")) if raw else None
+    except Exception:
+        body = None
+
+    if status == 401:
+        raise KeyWardenError(
+            (body or {}).get("reason", "your validation key was rejected"),
+            (body or {}).get("error", "unauthorized_client"),
+            401,
+        )
+    if status is None or status >= 500 or body is None:
+        raise KeyWardenError(
+            (body or {}).get("error", f"gateway error ({status})") if body else f"gateway error ({status})",
+            (body or {}).get("error", "validation_unavailable") if body else "validation_unavailable",
+            status,
+        )
+    # 200 with {valid} is the licence verdict - true or false, both normal.
+    return body
+
+
+def validate_or_verify(
+    key: str,
+    *,
+    cached_token: Optional[str] = None,
+    public_key: Optional[str] = None,
+    **kwargs: Any,
+) -> Dict[str, Any]:
+    """Validate online; on an unreachable gateway, fall back to a cached token.
+
+    A rejected validation key (401) is never masked by the offline path - only a
+    genuine reachability failure falls back.
+    """
+    try:
+        online = validate(key, **kwargs)
+        return {**online, "source": "online"}
+    except KeyWardenError as e:
+        if e.code not in ("unreachable", "timeout"):
+            raise
+        if not cached_token or not public_key:
+            raise
+        off = verify_token(cached_token, public_key)
+        return {**off, "source": "offline"}
+
+
+def machine_id_from(*parts: str) -> str:
+    """A stable, privacy-preserving machine id: SHA-256 over the parts you provide.
+
+    The raw parts never leave the machine - only their hash.
+    """
+    joined = "|".join(str(p) for p in parts if p)
+    if not joined:
+        raise KeyWardenError("machine_id_from() needs at least one non-empty part", "empty")
+    return hashlib.sha256(joined.encode("utf-8")).hexdigest()

keywarden-1.0.0/keywarden.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: keywarden
+Version: 1.0.0
+Summary: Official Python client for Key-Warden - validate software licences online (seat- and revocation-aware) or verify signed tokens offline against your embedded public key.
+Author: Key-Warden
+License: MIT
+Project-URL: Homepage, https://key-warden.com
+Project-URL: Documentation, https://key-warden.com/docs
+Project-URL: Issues, https://key-warden.com/contact
+Keywords: key-warden,keywarden,licence,license,licensing,activation,software-licensing,ed25519,offline-verification
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=3.4
+Dynamic: license-file
+
+# keywarden
+
+The official Python client for [Key-Warden](https://key-warden.com). Validate a
+software licence online — seat-aware, revocation-aware — or verify a signed token
+offline against your embedded public key, with no network round-trip.
+
+One dependency: [`cryptography`](https://pypi.org/project/cryptography/) (for
+Ed25519). Networking is stdlib `urllib`. Python 3.8+.
+
+```bash
+pip install keywarden
+```
+
+## Validate online
+
+The authoritative check. Ask the platform whether a licence is good *right now*.
+
+```python
+import os, socket
+import keywarden as kw
+
+res = kw.validate(
+    customer_licence_key,
+    apim_key=os.environ["KW_APIM_KEY"],      # your APIM subscription key
+    client_key=os.environ["KW_CLIENT_KEY"],  # your validation key
+    machine_id=kw.machine_id_from(socket.gethostname(), user_id),  # stable, hashed your side
+)
+
+if not res["valid"]:
+    raise SystemExit(f"licence not valid: {res.get('reason')}")
+# res["token"] is a freshly signed proof — cache it for the offline path below.
+```
+
+A `valid == False` (e.g. `revoked`, `expired`, `seat_limit_exceeded`) is **data**,
+not an error. A wrong `client_key` raises a `KeyWardenError` with
+`code == "unauthorized_client"` — that's *your* auth failing, and your customer
+should never see it as a licence problem.
+
+## Verify offline
+
+No connection? Verify a token you already hold against your **public** key —
+the 32-byte raw key from your vendor console. Pure, no network.
+
+```python
+check = kw.verify_token(cached_token, os.environ["KW_PUBLIC_KEY"])
+if not check["valid"]:
+    lock_features(check["reason"])  # "bad_signature" | "expired" | ...
+```
+
+The token is `header.body.signature` (compact JWT style) and the Ed25519
+signature covers the exact bytes `header.body`. This client verifies over those
+bytes — it never decodes-then-reverifies, which is the one mistake that silently
+breaks offline checks. Expiry is honoured within the offline grace window you set
+at mint time.
+
+## Online, with an offline fallback
+
+The pattern most desktop apps want: online is authoritative; if the network is
+down, keep working within grace.
+
+```python
+res = kw.validate_or_verify(
+    customer_licence_key,
+    apim_key=apim_key, client_key=client_key, machine_id=machine_id,
+    cached_token=last_good_token,            # from a previous validate()
+    public_key=os.environ["KW_PUBLIC_KEY"],
+)
+# res["source"] == "online" | "offline"
+```
+
+A rejected `client_key` (401) is never masked by the offline path — only a genuine
+reachability failure falls back.
+
+## API
+
+| Function | Purpose |
+|---|---|
+| `validate(key, *, apim_key, client_key, ...)` | Online check. Returns `{"valid", "reason"?, "activeSeats"?, "token"?}`. |
+| `verify_token(token, raw_pub_b64, *, now=None)` | Offline check. Returns `{"valid", "reason"?, "claims"?}`. |
+| `validate_or_verify(key, *, cached_token, public_key, ...)` | Online, falling back to a cached token when unreachable. |
+| `machine_id_from(*parts)` | A stable SHA-256 machine id; raw parts never leave the machine. |
+
+Any real failure (bad credentials, unreachable gateway, server error) raises
+`KeyWardenError`, which carries `.code` and `.status`.
+
+## Security notes
+
+- Your **private** signing key never leaves Key-Warden's Key Vault. You embed
+  only the 32-byte public half.
+- `machine_id` is hashed by the platform, but send an opaque, stable id — not a
+  raw MAC address or a hostname you wouldn't want logged. `machine_id_from()`
+  hashes on your side too.
+- Two independent credentials gate every online call: the APIM subscription key
+  gets you to the gateway, the validation key authenticates you as the vendor. A
+  leaked validation key can be rotated without reissuing a single customer
+  licence.
+
+## Licence
+
+MIT.

keywarden-1.0.0/keywarden.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+keywarden/__init__.py
+keywarden.egg-info/PKG-INFO
+keywarden.egg-info/SOURCES.txt
+keywarden.egg-info/dependency_links.txt
+keywarden.egg-info/requires.txt
+keywarden.egg-info/top_level.txt

keywarden-1.0.0/keywarden.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

keywarden-1.0.0/keywarden.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography>=3.4

keywarden-1.0.0/keywarden.egg-info/top_level.txt

@@ -0,0 +1 @@
+keywarden

keywarden-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "keywarden"
+version = "1.0.0"
+description = "Official Python client for Key-Warden - validate software licences online (seat- and revocation-aware) or verify signed tokens offline against your embedded public key."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Key-Warden" }]
+keywords = [
+    "key-warden", "keywarden", "licence", "license", "licensing",
+    "activation", "software-licensing", "ed25519", "offline-verification",
+]
+dependencies = ["cryptography>=3.4"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Security :: Cryptography",
+]
+
+[project.urls]
+Homepage = "https://key-warden.com"
+Documentation = "https://key-warden.com/docs"
+Issues = "https://key-warden.com/contact"
+
+[tool.setuptools]
+packages = ["keywarden"]

keywarden-1.0.0/setup.cfg

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