ndaedzo-shared-lib 0.1.0__py3-none-any.whl

jwt_auth/__init__.py

@@ -0,0 +1,40 @@
+"""jwt_auth: production-ready JWT access/refresh token issuance and verification.
+
+Typical usage:
+
+    from jwt_auth import JWTManager
+
+    manager = JWTManager()  # reads configuration from the environment
+    tokens = manager.create_token_pair(subject="user-123")
+    payload = manager.verify_access_token(tokens.access_token)
+"""
+
+from .config import JWTSettings
+from .exceptions import (
+    ConfigurationError,
+    InvalidTokenError,
+    InvalidTokenTypeError,
+    JWTError,
+    TokenExpiredError,
+    TokenRevokedError,
+)
+from .manager import ACCESS_TOKEN_TYPE, REFRESH_TOKEN_TYPE, JWTManager
+from .models import TokenPair, TokenPayload
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "JWTManager",
+    "JWTSettings",
+    "TokenPair",
+    "TokenPayload",
+    "JWTError",
+    "ConfigurationError",
+    "TokenExpiredError",
+    "InvalidTokenError",
+    "InvalidTokenTypeError",
+    "TokenRevokedError",
+    "ACCESS_TOKEN_TYPE",
+    "REFRESH_TOKEN_TYPE",
+    "__version__",
+]

jwt_auth/config.py

@@ -0,0 +1,92 @@
+"""Environment-driven configuration for JWTManager."""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from .exceptions import ConfigurationError
+
+_dotenv_loaded = False
+
+
+def _ensure_dotenv_loaded() -> None:
+    global _dotenv_loaded
+    if not _dotenv_loaded:
+        load_dotenv()
+        _dotenv_loaded = True
+
+
+def _read_key_material(raw: str | None, path: str | None) -> str | None:
+    """Resolve key material from either a raw PEM env var or a path to a PEM file.
+
+    Raw values may contain literal ``\\n`` sequences (common when a PEM is
+    stored as a single-line environment variable) and are unescaped.
+    """
+    if raw:
+        return raw.replace("\\n", "\n")
+    if path:
+        key_path = Path(path)
+        if not key_path.is_file():
+            raise ConfigurationError(f"Key file not found: {key_path}")
+        return key_path.read_text(encoding="utf-8")
+    return None
+
+
+@dataclass(frozen=True)
+class JWTSettings:
+    """Configuration for a JWTManager.
+
+    Prefer building this via `JWTSettings.from_env()`. Construct it directly
+    when wiring up tests or when configuration comes from somewhere other
+    than the process environment (e.g. a secrets manager).
+    """
+
+    algorithm: str = "RS256"
+    private_key: str | None = None
+    public_key: str | None = None
+    secret_key: str | None = None
+    access_token_expire_minutes: int = 15
+    refresh_token_expire_days: int = 7
+    issuer: str | None = None
+    audience: str | None = None
+
+    @classmethod
+    def from_env(cls, *, load_dotenv_file: bool = True) -> "JWTSettings":
+        """Build settings from environment variables (optionally loading a .env file first).
+
+        Recognized variables:
+            JWT_ALGORITHM                     default "RS256"
+            JWT_PRIVATE_KEY / JWT_PRIVATE_KEY_PATH   (asymmetric algorithms)
+            JWT_PUBLIC_KEY  / JWT_PUBLIC_KEY_PATH    (asymmetric algorithms)
+            JWT_SECRET_KEY                    (symmetric algorithms, e.g. HS256)
+            JWT_ACCESS_TOKEN_EXPIRE_MINUTES   default 15
+            JWT_REFRESH_TOKEN_EXPIRE_DAYS     default 7
+            JWT_ISSUER                        optional
+            JWT_AUDIENCE                      optional
+        """
+        if load_dotenv_file:
+            _ensure_dotenv_loaded()
+
+        private_key = _read_key_material(
+            os.getenv("JWT_PRIVATE_KEY"), os.getenv("JWT_PRIVATE_KEY_PATH")
+        )
+        public_key = _read_key_material(
+            os.getenv("JWT_PUBLIC_KEY"), os.getenv("JWT_PUBLIC_KEY_PATH")
+        )
+
+        return cls(
+            algorithm=os.getenv("JWT_ALGORITHM", "RS256").upper(),
+            private_key=private_key,
+            public_key=public_key,
+            secret_key=os.getenv("JWT_SECRET_KEY") or None,
+            access_token_expire_minutes=int(
+                os.getenv("JWT_ACCESS_TOKEN_EXPIRE_MINUTES", "15")
+            ),
+            refresh_token_expire_days=int(
+                os.getenv("JWT_REFRESH_TOKEN_EXPIRE_DAYS", "7")
+            ),
+            issuer=os.getenv("JWT_ISSUER") or None,
+            audience=os.getenv("JWT_AUDIENCE") or None,
+        )

jwt_auth/exceptions.py

@@ -0,0 +1,32 @@
+"""Exception hierarchy for jwt_auth.
+
+All exceptions raised by this library inherit from JWTError, so callers who
+don't care about the distinction can catch a single type.
+"""
+
+
+class JWTError(Exception):
+    """Base class for every exception raised by jwt_auth."""
+
+
+class ConfigurationError(JWTError):
+    """Raised when a JWTManager is misconfigured (e.g. missing key material)."""
+
+
+class TokenExpiredError(JWTError):
+    """Raised when a token's `exp` claim is in the past."""
+
+
+class InvalidTokenError(JWTError):
+    """Raised when a token is malformed, has an invalid signature, or fails
+    standard claim validation (issuer, audience, not-before, etc.)."""
+
+
+class InvalidTokenTypeError(JWTError):
+    """Raised when a token's `type` claim doesn't match the operation being
+    performed (e.g. a refresh token presented where an access token is required)."""
+
+
+class TokenRevokedError(JWTError):
+    """Raised when a token has been revoked, as reported by the manager's
+    `is_revoked` callback."""

jwt_auth/manager.py

@@ -0,0 +1,251 @@
+"""Core token issuance and verification logic."""
+
+import uuid
+from collections.abc import Callable
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import jwt as pyjwt
+
+from .config import JWTSettings
+from .exceptions import (
+    ConfigurationError,
+    InvalidTokenError,
+    InvalidTokenTypeError,
+    TokenExpiredError,
+    TokenRevokedError,
+)
+from .models import TokenPair, TokenPayload
+
+ACCESS_TOKEN_TYPE = "access"
+REFRESH_TOKEN_TYPE = "refresh"
+
+_ASYMMETRIC_ALGORITHMS = {
+    "RS256", "RS384", "RS512",
+    "ES256", "ES384", "ES512",
+    "PS256", "PS384", "PS512",
+}
+_SYMMETRIC_ALGORITHMS = {"HS256", "HS384", "HS512"}
+_SUPPORTED_ALGORITHMS = _ASYMMETRIC_ALGORITHMS | _SYMMETRIC_ALGORITHMS
+
+_RESERVED_CLAIMS = {"sub", "type", "jti", "iat", "nbf", "exp", "iss", "aud"}
+
+
+class JWTManager:
+    """Issues and verifies access/refresh token pairs.
+
+    For asymmetric algorithms (RS256 and friends) a manager only needs the
+    private key to *issue* tokens and only the public key to *verify* them,
+    so a downstream microservice that just needs to check tokens can be
+    configured with a public key alone.
+
+    An optional `is_revoked` callback lets callers plug in a denylist (e.g.
+    backed by Redis) to reject tokens by their `jti` before they've expired,
+    without this library taking a dependency on any particular store.
+    """
+
+    def __init__(
+        self,
+        settings: JWTSettings | None = None,
+        *,
+        is_revoked: Callable[[str], bool] | None = None,
+    ) -> None:
+        self.settings = settings or JWTSettings.from_env()
+        self._is_revoked = is_revoked
+        self._validate_settings()
+
+    def _validate_settings(self) -> None:
+        algorithm = self.settings.algorithm
+        if algorithm in _ASYMMETRIC_ALGORITHMS:
+            if not self.settings.private_key and not self.settings.public_key:
+                raise ConfigurationError(
+                    f"Algorithm {algorithm} needs a private key (to sign), a public "
+                    "key (to verify), or both. Set JWT_PRIVATE_KEY[_PATH] and/or "
+                    "JWT_PUBLIC_KEY[_PATH]."
+                )
+        elif algorithm in _SYMMETRIC_ALGORITHMS:
+            if not self.settings.secret_key:
+                raise ConfigurationError(
+                    f"Algorithm {algorithm} requires JWT_SECRET_KEY to be set."
+                )
+        else:
+            raise ConfigurationError(
+                f"Unsupported algorithm: {algorithm!r}. Supported: "
+                f"{sorted(_SUPPORTED_ALGORITHMS)}"
+            )
+
+    @property
+    def _signing_key(self) -> str:
+        algorithm = self.settings.algorithm
+        if algorithm in _ASYMMETRIC_ALGORITHMS:
+            if not self.settings.private_key:
+                raise ConfigurationError(
+                    f"No private key configured; this manager can verify {algorithm} "
+                    "tokens but cannot issue them."
+                )
+            return self.settings.private_key
+        assert self.settings.secret_key is not None
+        return self.settings.secret_key
+
+    @property
+    def _verification_key(self) -> str:
+        algorithm = self.settings.algorithm
+        if algorithm in _ASYMMETRIC_ALGORITHMS:
+            key = self.settings.public_key or self.settings.private_key
+            assert key is not None
+            return key
+        assert self.settings.secret_key is not None
+        return self.settings.secret_key
+
+    def _build_payload(
+        self,
+        subject: str,
+        token_type: str,
+        expires_delta: timedelta,
+        extra_claims: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        if extra_claims:
+            collisions = _RESERVED_CLAIMS & extra_claims.keys()
+            if collisions:
+                raise ValueError(f"extra_claims may not override reserved claims: {collisions}")
+
+        now = datetime.now(timezone.utc)
+        payload: dict[str, Any] = {
+            "sub": subject,
+            "type": token_type,
+            "jti": str(uuid.uuid4()),
+            "iat": now,
+            "nbf": now,
+            "exp": now + expires_delta,
+        }
+        if self.settings.issuer:
+            payload["iss"] = self.settings.issuer
+        if self.settings.audience:
+            payload["aud"] = self.settings.audience
+        if extra_claims:
+            payload.update(extra_claims)
+        return payload
+
+    def create_access_token(
+        self, subject: str, extra_claims: dict[str, Any] | None = None
+    ) -> str:
+        """Issue a short-lived access token for `subject` (typically a user id)."""
+        payload = self._build_payload(
+            subject,
+            ACCESS_TOKEN_TYPE,
+            timedelta(minutes=self.settings.access_token_expire_minutes),
+            extra_claims,
+        )
+        return pyjwt.encode(payload, self._signing_key, algorithm=self.settings.algorithm)
+
+    def create_refresh_token(
+        self, subject: str, extra_claims: dict[str, Any] | None = None
+    ) -> str:
+        """Issue a long-lived refresh token for `subject`."""
+        payload = self._build_payload(
+            subject,
+            REFRESH_TOKEN_TYPE,
+            timedelta(days=self.settings.refresh_token_expire_days),
+            extra_claims,
+        )
+        return pyjwt.encode(payload, self._signing_key, algorithm=self.settings.algorithm)
+
+    def create_token_pair(
+        self, subject: str, extra_claims: dict[str, Any] | None = None
+    ) -> TokenPair:
+        """Issue an access/refresh token pair in one call."""
+        return TokenPair(
+            access_token=self.create_access_token(subject, extra_claims),
+            refresh_token=self.create_refresh_token(subject, extra_claims),
+            expires_in=self.settings.access_token_expire_minutes * 60,
+        )
+
+    def _decode(self, token: str) -> dict[str, Any]:
+        try:
+            return pyjwt.decode(
+                token,
+                self._verification_key,
+                algorithms=[self.settings.algorithm],
+                issuer=self.settings.issuer,
+                audience=self.settings.audience,
+                options={"require": ["exp", "iat", "sub", "jti", "type"]},
+            )
+        except pyjwt.ExpiredSignatureError as exc:
+            raise TokenExpiredError("Token has expired.") from exc
+        except pyjwt.InvalidTokenError as exc:
+            raise InvalidTokenError(f"Token is invalid: {exc}") from exc
+
+    def _verify(self, token: str, expected_type: str) -> TokenPayload:
+        payload = self._decode(token)
+
+        actual_type = payload.get("type")
+        if actual_type != expected_type:
+            raise InvalidTokenTypeError(
+                f"Expected a '{expected_type}' token but received '{actual_type}'."
+            )
+
+        if self._is_revoked is not None and self._is_revoked(payload["jti"]):
+            raise TokenRevokedError(f"Token '{payload['jti']}' has been revoked.")
+
+        return TokenPayload(
+            sub=payload["sub"],
+            jti=payload["jti"],
+            token_type=actual_type,
+            issued_at=int(payload["iat"]),
+            expires_at=int(payload["exp"]),
+            issuer=payload.get("iss"),
+            audience=payload.get("aud"),
+            claims={k: v for k, v in payload.items() if k not in _RESERVED_CLAIMS},
+        )
+
+    def verify_access_token(self, token: str) -> TokenPayload:
+        """Verify signature, expiry, and type; raise if the token isn't a valid access token."""
+        return self._verify(token, ACCESS_TOKEN_TYPE)
+
+    def verify_refresh_token(self, token: str) -> TokenPayload:
+        """Verify signature, expiry, and type; raise if the token isn't a valid refresh token."""
+        return self._verify(token, REFRESH_TOKEN_TYPE)
+
+    def refresh_access_token(
+        self, refresh_token: str, *, rotate_refresh_token: bool = False
+    ) -> TokenPair:
+        """Exchange a valid refresh token for a new access token.
+
+        With `rotate_refresh_token=True`, a new refresh token is also issued
+        (recommended for refresh token rotation); otherwise the original
+        refresh token is returned unchanged. Rotation requires pairing this
+        library with a store that invalidates the old refresh token's `jti`
+        (via the `is_revoked` callback) to prevent reuse after rotation.
+        """
+        payload = self.verify_refresh_token(refresh_token)
+        extra_claims = payload.claims or None
+
+        new_refresh_token = refresh_token
+        if rotate_refresh_token:
+            new_refresh_token = self.create_refresh_token(payload.sub, extra_claims)
+
+        return TokenPair(
+            access_token=self.create_access_token(payload.sub, extra_claims),
+            refresh_token=new_refresh_token,
+            expires_in=self.settings.access_token_expire_minutes * 60,
+        )
+
+    def is_token_expired(self, token: str) -> bool:
+        """Return True if the token's signature is valid but it has expired.
+
+        Raises InvalidTokenError for any other validation failure (bad
+        signature, malformed token, wrong issuer/audience, etc.).
+        """
+        try:
+            self._decode(token)
+        except TokenExpiredError:
+            return True
+        return False
+
+    def get_unverified_claims(self, token: str) -> dict[str, Any]:
+        """Decode a token's claims WITHOUT verifying its signature or expiry.
+
+        Use only for non-authoritative purposes (logging, debugging). Never
+        use the result to make authorization decisions.
+        """
+        return pyjwt.decode(token, options={"verify_signature": False})

jwt_auth/models.py

@@ -0,0 +1,28 @@
+"""Plain data types returned by JWTManager."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class TokenPair:
+    """An access/refresh token pair, ready to hand back to a client."""
+
+    access_token: str
+    refresh_token: str
+    token_type: str = "Bearer"
+    expires_in: int = 0  # seconds until the access token expires
+
+
+@dataclass(frozen=True)
+class TokenPayload:
+    """The verified, decoded contents of a token."""
+
+    sub: str
+    jti: str
+    token_type: str
+    issued_at: int
+    expires_at: int
+    issuer: str | None = None
+    audience: str | None = None
+    claims: dict[str, Any] = field(default_factory=dict)

ndaedzo_shared_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.5
+Name: ndaedzo-shared-lib
+Version: 0.1.0
+Summary: Production-ready JWT access/refresh token issuance and verification library for microservices.
+Requires-Python: >=3.10
+Requires-Dist: pyjwt[crypto]>=2.10.1
+Requires-Dist: python-dotenv>=1.0.1
+Description-Content-Type: text/markdown
+
+# shared-lib
+
+A production-ready JWT authentication library for issuing and verifying access and refresh tokens across microservices, built on [PyJWT](https://pyjwt.readthedocs.io/) and managed with [uv](https://docs.astral.sh/uv/).
+
+## Features
+
+- Access token + refresh token issuance, individually or as a pair
+- Token verification with signature, expiry, not-before, issuer, and audience checks
+- Strict token-type separation - a refresh token can never be used where an access token is expected, and vice versa
+- Refresh token rotation (`refresh_access_token(..., rotate_refresh_token=True)`)
+- Pluggable revocation - pass an `is_revoked(jti) -> bool` callback backed by whatever store you use (Redis, a database, ...) to reject tokens by ID before they expire
+- Asymmetric (RS256/ES256/PS256) and symmetric (HS256) algorithm support, configured entirely via environment variables
+- Typed dataclasses (`TokenPair`, `TokenPayload`) and a small, specific exception hierarchy instead of stringly-typed errors
+- Full unittest suite and GitHub Actions CI
+
+## Why RS256 for microservices
+
+With a symmetric algorithm (HS256), every service that needs to verify a token must hold the exact same secret used to sign it - so the secret has to be distributed to every service, and any one of them leaking it lets an attacker forge tokens for the whole system.
+
+With an asymmetric algorithm (RS256), only the service that issues tokens (e.g. an auth service) holds the private key. Every other service is configured with just the public key, which is enough to verify a token's signature but not to create new ones. This is the recommended default for a microservices setup and is what this library uses out of the box.
+
+## Installation
+
+This repo is managed with `uv`. From the project root:
+
+```bash
+uv sync
+```
+
+To use `jwt_auth` from another project in this workspace/monorepo, add it as a path or git dependency with `uv add`.
+
+## Quickstart
+
+1. Copy the example environment file and generate a dev key pair:
+
+   ```bash
+   cp .env.example .env
+   uv run python scripts/generate_keys.py
+   ```
+
+   This writes `keys/private_key.pem` and `keys/public_key.pem` (both gitignored). The default `.env` already points `JWT_PRIVATE_KEY_PATH` / `JWT_PUBLIC_KEY_PATH` at these files.
+
+2. Run the demo:
+
+   ```bash
+   uv run main.py
+   ```
+
+3. Use it in code:
+
+   ```python
+   from jwt_auth import JWTManager, TokenExpiredError, InvalidTokenError
+
+   manager = JWTManager()  # reads configuration from the environment
+
+   tokens = manager.create_token_pair(subject="user-123", extra_claims={"role": "trainer"})
+   # tokens.access_token, tokens.refresh_token, tokens.expires_in
+
+   try:
+       payload = manager.verify_access_token(tokens.access_token)
+       user_id = payload.sub
+   except TokenExpiredError:
+       ...  # ask the client to hit the refresh endpoint
+   except InvalidTokenError:
+       ...  # reject the request, log the attempt
+   ```
+
+4. Refreshing an access token:
+
+   ```python
+   new_tokens = manager.refresh_access_token(refresh_token, rotate_refresh_token=True)
+   ```
+
+## Auth service vs. downstream services
+
+Because RS256 keys are asymmetric, a downstream service that only ever needs to *verify* tokens should be configured with just the public key - it will raise `ConfigurationError` if you try to issue a token with it:
+
+```python
+# Auth service - has both keys, can issue and verify.
+issuer = JWTManager()  # JWT_PRIVATE_KEY_PATH and JWT_PUBLIC_KEY_PATH set
+
+# Downstream service - only distribute the public key.
+verifier = JWTManager(JWTSettings(algorithm="RS256", public_key=public_key_pem))
+verifier.verify_access_token(incoming_token)  # OK
+verifier.create_access_token("user-1")        # raises ConfigurationError
+```
+
+## Revocation
+
+This library doesn't ship a storage backend, since that choice (Redis, Postgres, ...) belongs to the application. Instead, `JWTManager` accepts an `is_revoked` callback:
+
+```python
+def is_revoked(jti: str) -> bool:
+    return redis_client.sismember("revoked-jtis", jti)
+
+manager = JWTManager(is_revoked=is_revoked)
+```
+
+Every `verify_access_token` / `verify_refresh_token` call runs the token's `jti` through this callback, so revoking a token (on logout, on rotation, or by an admin) just means adding its `jti` to your store.
+
+## Configuration reference
+
+All configuration is read from the environment (optionally via a `.env` file, loaded automatically the first time `JWTSettings.from_env()` runs).
+
+| Variable | Required | Default | Notes |
+|---|---|---|---|
+| `JWT_ALGORITHM` | no | `RS256` | Any PyJWT-supported algorithm: `RS256/384/512`, `ES256/384/512`, `PS256/384/512`, `HS256/384/512` |
+| `JWT_PRIVATE_KEY_PATH` / `JWT_PRIVATE_KEY` | for asymmetric algorithms, to issue tokens | - | Path to a PEM file, or the raw PEM (with `\n` escapes) |
+| `JWT_PUBLIC_KEY_PATH` / `JWT_PUBLIC_KEY` | for asymmetric algorithms, to verify tokens | - | Path to a PEM file, or the raw PEM (with `\n` escapes) |
+| `JWT_SECRET_KEY` | for symmetric algorithms | - | Shared secret |
+| `JWT_ACCESS_TOKEN_EXPIRE_MINUTES` | no | `15` | Keep this short - access tokens are bearer credentials |
+| `JWT_REFRESH_TOKEN_EXPIRE_DAYS` | no | `7` | |
+| `JWT_ISSUER` | no | - | Stamped as `iss` and enforced on verify when set |
+| `JWT_AUDIENCE` | no | - | Stamped as `aud` and enforced on verify when set |
+
+See `.env.example` for a template.
+
+## Testing
+
+```bash
+uv run python -m unittest discover -s tests -t . -v
+```
+
+Tests cover both HS256 and RS256 code paths, token-type separation, tampering/wrong-key/wrong-audience rejection, expiry, refresh rotation, revocation, and configuration validation - no network or external services required.
+
+## CI
+
+`.github/workflows/ci.yml` runs on every push and pull request to `main`: it lints with `ruff`, runs the full test suite across Python 3.10-3.13 via `uv`, and does a final build check. Update this library, push, and CI will catch regressions before they reach any service that depends on it.
+
+## Security notes
+
+- Keep access token lifetimes short (minutes) and refresh token lifetimes as short as your product allows (days, not months).
+- Prefer RS256 (or another asymmetric algorithm) over HS256 whenever more than one service needs to verify tokens.
+- Use `rotate_refresh_token=True` and pair it with the `is_revoked` callback so a stolen, already-rotated refresh token can be rejected on reuse.
+- Never log full tokens. `TokenPayload.jti` is safe to log; the raw token string is a bearer credential.
+- Always serve token endpoints over HTTPS.
+- `keys/`, `.env`, and `*.pem` are gitignored - do not commit real key material or secrets.

ndaedzo_shared_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+jwt_auth/__init__.py,sha256=PWqNElWOQQCeVQk_hVi2whKYv7RbSl1d88DmMxrqJvk,971
+jwt_auth/config.py,sha256=Rxzlq1xl_QVFDkOGdO_h58Fn3Dn9ti3DTje7A1t2MUY,3183
+jwt_auth/exceptions.py,sha256=MVZuzf-ugGwNoprO1yT-07fXgaKlvdhodg4_snvoSa4,1009
+jwt_auth/manager.py,sha256=DU_5dFOrJ6Z5YtIF19mCpniQX99QOOXR_bJBTzbru8Q,9598
+jwt_auth/models.py,sha256=1CY9gTLFjg4huyvoYwqIx3RPHbMeKp8xfEiI4nEnD-4,674
+jwt_auth/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ndaedzo_shared_lib-0.1.0.dist-info/METADATA,sha256=D0bXj-WnNIClgo_5d_8Cka9xi-uKLiOiFQ-sWFMb87E,6934
+ndaedzo_shared_lib-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+ndaedzo_shared_lib-0.1.0.dist-info/RECORD,,

ndaedzo_shared_lib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any