nitroping 0.1.3__py3-none-any.whl

nitroping/types.py

@@ -0,0 +1,100 @@
+"""Shared request / response types for the nitroping HTTP API.
+
+The wire shape mirrors ``POST /api/v1/notifications`` on the
+nitroping-pro server. Field names are snake_case on the wire; the SDK
+accepts the same snake_case names on input so there is no impedance
+mismatch with the server.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+#: Supported device platforms.
+Platform = Literal["ios", "android", "web"]
+
+
+class _NotificationActionBase(TypedDict):
+    id: str
+    title: str
+
+
+class NotificationAction(_NotificationActionBase, total=False):
+    """Action button rendered on the notification (where the platform
+    supports it)."""
+
+    icon: str
+
+
+class TargetAll(TypedDict):
+    """Broadcast target — every active device."""
+
+    all: bool
+
+
+class TargetDeviceIds(TypedDict):
+    """Hit specific device rows."""
+
+    device_ids: list[str]
+
+
+class TargetUserIds(TypedDict):
+    """Hit every device row a user owns."""
+
+    user_ids: list[str]
+
+
+#: Target selector for a notification. Exactly one of the three.
+NotificationTarget = TargetAll | TargetDeviceIds | TargetUserIds
+
+
+class SendOptions(TypedDict, total=False):
+    """Per-call overrides for :meth:`NotificationsClient.send`.
+
+    ``idempotency_key`` — if the same key + the same body is sent again
+    the server replays the cached response within 24 hours. Same key +
+    different body returns a 409 (``idempotency_conflict``). Max 255
+    characters.
+    """
+
+    idempotency_key: str
+
+
+class NotificationResult(TypedDict):
+    """Response from ``POST /api/v1/notifications``."""
+
+    #: UUID of the notification row.
+    id: str
+    #: Initial status, usually ``"queued"``.
+    status: str
+
+
+class RegisterDeviceResult(TypedDict):
+    """Response from ``POST /api/v1/devices``."""
+
+    #: UUID of the device row.
+    id: str
+    #: ``True`` if the device was created on this request; ``False`` if it
+    #: already existed.
+    created: bool
+
+
+class DeactivateDeviceResult(TypedDict):
+    """Response from ``DELETE /api/v1/devices/:id``."""
+
+    id: str
+    status: str
+
+
+class WebhookEvent(TypedDict):
+    """Outbound webhook event envelope (parsed from a
+    :func:`nitroping.webhooks.verify` call)."""
+
+    #: Event id, prefixed with ``evt_``.
+    id: str
+    #: Event type, e.g. ``"notification.delivered"``, ``"webhook.test"``.
+    type: str
+    #: ISO-8601 timestamp set when the event was queued.
+    created_at: str
+    #: Event-specific payload.
+    data: dict[str, Any]

nitroping/webhooks.py

@@ -0,0 +1,160 @@
+"""Verify outbound webhook signatures.
+
+The nitroping server signs every outbound webhook with HMAC-SHA256 and
+ships the result in the ``X-Nitroping-Signature`` header. The header
+format mirrors Polar / Stripe::
+
+    X-Nitroping-Signature: t=1700000000, v1=<hex>
+
+where ``v1 = HMAC-SHA256(secret, "<unix>.<raw body>")``.
+
+Example::
+
+    from nitroping.webhooks import verify
+
+    event = verify(
+        body=raw_body_bytes,
+        signature=request.headers["x-nitroping-signature"],
+        secret=os.environ["NITROPING_WEBHOOK_SECRET"],
+    )
+    if event["type"] == "notification.delivered":
+        ...
+
+Zero deps — :mod:`hmac` and :mod:`hashlib` from the stdlib.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import re
+import time
+from typing import cast
+
+from .errors import (
+    InvalidSignatureError,
+    MissingSignatureHeaderError,
+    NitropingError,
+    TimestampOutOfRangeError,
+)
+from .types import WebhookEvent
+
+__all__ = ["sign", "verify"]
+
+_HEX_RE = re.compile(r"^[0-9a-f]+$", re.IGNORECASE)
+
+
+def verify(
+    *,
+    body: bytes | str,
+    signature: str | None,
+    secret: str,
+    tolerance: int = 300,
+    now: int | float | None = None,
+) -> WebhookEvent:
+    """Verify and parse a webhook delivery.
+
+    :param body: Raw request body, exactly as received (do **not**
+        re-serialize a parsed JSON object — whitespace and key order
+        matter to the HMAC).
+    :param signature: The ``X-Nitroping-Signature`` header value, or
+        ``None`` if the header was missing.
+    :param secret: Webhook signing secret, configured in the app panel.
+    :param tolerance: Maximum drift between ``t=`` and the verifier's
+        wall clock, in seconds. Default: 300 (five minutes). Set lower
+        for stricter replay defense.
+    :param now: Override "now" — useful for tests and replaying a saved
+        request during incident investigation. Unix seconds.
+
+    :returns: The parsed :class:`~nitroping.types.WebhookEvent`.
+
+    :raises MissingSignatureHeaderError: ``signature`` was ``None``.
+    :raises InvalidSignatureError: header malformed or HMAC mismatch.
+    :raises TimestampOutOfRangeError: signature valid but ``t=`` outside
+        the tolerance window.
+    :raises NitropingError: body wasn't valid JSON (``code = "invalid_body"``).
+    """
+    if signature is None:
+        raise MissingSignatureHeaderError()
+
+    parsed = _parse_signature_header(signature)
+    if parsed is None:
+        raise InvalidSignatureError("Malformed X-Nitroping-Signature header")
+    t, v1 = parsed
+
+    raw_body: bytes
+    raw_body_str: str
+    if isinstance(body, bytes):
+        raw_body = body
+        raw_body_str = body.decode("utf-8", errors="replace")
+    else:
+        raw_body_str = body
+        raw_body = body.encode()
+
+    expected = _hmac_sha256_hex(secret, f"{t}.".encode() + raw_body)
+
+    # Constant-time compare via hmac.compare_digest. Both inputs are
+    # lowercase hex of the same length when the header is well-formed;
+    # if the lengths differ compare_digest still runs in constant time
+    # for the length of the shorter input.
+    if not hmac.compare_digest(expected, v1):
+        raise InvalidSignatureError()
+
+    current = int(time.time()) if now is None else int(now)
+    if abs(current - t) > tolerance:
+        raise TimestampOutOfRangeError(
+            f"Webhook timestamp {t} is more than {tolerance}s from now ({current})"
+        )
+
+    try:
+        event = json.loads(raw_body_str)
+    except json.JSONDecodeError as cause:
+        raise NitropingError(
+            "Webhook body is not valid JSON",
+            code="invalid_body",
+            cause=cause,
+        ) from cause
+
+    return cast(WebhookEvent, event)
+
+
+def sign(secret: str, body: bytes | str, timestamp: int | float | None = None) -> str:
+    """Compute a header value for the nitroping signing scheme.
+
+    Mostly useful for tests; production code should rely on the server.
+    """
+    t = int(time.time()) if timestamp is None else int(timestamp)
+    body_bytes = body.encode("utf-8") if isinstance(body, str) else body
+    v1 = _hmac_sha256_hex(secret, f"{t}.".encode() + body_bytes)
+    return f"t={t}, v1={v1}"
+
+
+def _parse_signature_header(header: str) -> tuple[int, str] | None:
+    """Parse ``t=<unix>, v1=<hex>``. Tolerant of extra whitespace and
+    ordering — match by key. Returns ``None`` on malformed input."""
+    parts = [piece.strip() for piece in header.split(",")]
+    t: int | None = None
+    v1: str | None = None
+    for part in parts:
+        eq = part.find("=")
+        if eq <= 0:
+            continue
+        key = part[:eq].strip()
+        value = part[eq + 1 :].strip()
+        if key == "t":
+            try:
+                t = int(value)
+            except ValueError:
+                return None
+        elif key == "v1":
+            if not _HEX_RE.match(value):
+                return None
+            v1 = value.lower()
+    if t is None or v1 is None:
+        return None
+    return t, v1
+
+
+def _hmac_sha256_hex(secret: str, message: bytes) -> str:
+    return hmac.new(secret.encode(), message, hashlib.sha256).hexdigest()

nitroping-0.1.3.dist-info/METADATA

@@ -0,0 +1,426 @@
+Metadata-Version: 2.4
+Name: nitroping
+Version: 0.1.3
+Summary: Zero-dependency Python SDK for nitroping push notifications. Send pushes, register devices, verify webhooks.
+Project-URL: Homepage, https://nitroping.dev
+Project-URL: Repository, https://github.com/productdevbook/nitroping-sdk
+Project-URL: Issues, https://github.com/productdevbook/nitroping-sdk/issues
+Project-URL: Documentation, https://nitroping.dev/docs
+Author: productdevbook
+License: MIT
+Keywords: apns,fcm,nitroping,notifications,push,sdk,web-push
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+> Part of the [**nitroping-sdk**](https://github.com/productdevbook/nitroping-sdk) monorepo.
+> The PyPI package name (`nitroping`) is unchanged. See the [top-level README](../README.md) for SDKs in other languages.
+
+<p align="center">
+  <br>
+  <b style="font-size: 2em;">nitroping-python</b>
+  <br><br>
+  Zero-dependency Python SDK for <a href="https://nitroping.dev">nitroping</a>.
+  <br>
+  Send push notifications, register devices, verify webhooks. Pure stdlib, runs on Python 3.10+.
+  <br><br>
+  <a href="https://pypi.org/project/nitroping/"><img src="https://img.shields.io/pypi/v/nitroping?style=flat&colorA=18181B&colorB=34d399" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/nitroping/"><img src="https://img.shields.io/pypi/pyversions/nitroping?style=flat&colorA=18181B&colorB=34d399" alt="Python versions"></a>
+  <a href="https://pypi.org/project/nitroping/"><img src="https://img.shields.io/pypi/dm/nitroping?style=flat&colorA=18181B&colorB=34d399" alt="PyPI downloads"></a>
+  <a href="https://github.com/productdevbook/nitroping-sdk/blob/main/LICENSE"><img src="https://img.shields.io/github/license/productdevbook/nitroping-sdk?style=flat&colorA=18181B&colorB=34d399" alt="license"></a>
+</p>
+
+## Why nitroping?
+
+[nitroping](https://nitroping.dev) is a hosted push notification service that
+unifies APNs (iOS), FCM (Android), and Web Push behind one API. Send to a
+single device, a user across all of their devices, or every device in your app
+with one HTTP call. The service handles fanout, retries, idempotency, quota
+and outbound webhooks for delivery state — you write the product, not the
+plumbing.
+
+`nitroping` (Python) is the official Python client. It has **zero runtime
+dependencies**, ships type stubs (PEP 561), and runs anywhere CPython 3.10+
+runs: Django, FastAPI, Flask, Celery workers, AWS Lambda, plain scripts. The
+package weighs in under 30 kB.
+
+## Install
+
+```sh
+pip install nitroping
+# or
+uv pip install nitroping
+# or
+poetry add nitroping
+```
+
+## Quick Start
+
+### Send a notification
+
+```python
+import os
+from nitroping import Nitroping
+
+np = Nitroping(api_key=os.environ["NITROPING_API_KEY"])
+
+result = np.notifications.send(
+    title="Order #4129 shipped",
+    body="Your package is on its way.",
+    deep_link="https://example.com/orders/4129",
+    actions=[
+        {"id": "track", "title": "Track"},
+        {"id": "view", "title": "View order"},
+    ],
+    target={"user_ids": ["user-42"]},
+    idempotency_key="order-shipped-4129",
+)
+
+print(result["id"], result["status"])  # "abc-...", "queued"
+```
+
+### Register a device (server side)
+
+```python
+np.devices.register(
+    platform="ios",
+    token=device_token,           # raw APNs hex token
+    user_id="user-42",
+    metadata={"app_version": "2.4.1"},
+)
+```
+
+### Verify a webhook
+
+```python
+import os
+from nitroping.webhooks import verify
+from nitroping.errors import (
+    InvalidSignatureError,
+    TimestampOutOfRangeError,
+    MissingSignatureHeaderError,
+)
+
+def handle_webhook(raw_body: bytes, signature_header: str | None) -> None:
+    try:
+        event = verify(
+            body=raw_body,
+            signature=signature_header,
+            secret=os.environ["NITROPING_WEBHOOK_SECRET"],
+        )
+    except (InvalidSignatureError, TimestampOutOfRangeError, MissingSignatureHeaderError):
+        # Reject with HTTP 400 — do NOT leak which check failed.
+        raise
+
+    if event["type"] == "notification.delivered":
+        print("delivered", event["data"]["notification_id"])
+```
+
+## Sync and async
+
+`Nitroping` is synchronous and uses only the stdlib (`urllib.request`).
+
+`AsyncNitroping` exposes the same API as coroutines. It wraps the sync
+client and runs each call on the default executor via
+`asyncio.get_running_loop().run_in_executor(None, ...)`. This is a
+**best-effort wrapper** — it keeps the SDK zero-dependency and lets you
+`await` from FastAPI / aiohttp / Starlette without surprises, but it is not
+true non-blocking I/O. For high-fanout workloads (thousands of concurrent
+sends) bring your own async HTTP client and call the API directly.
+
+```python
+import asyncio
+from nitroping import AsyncNitroping
+
+async def main() -> None:
+    np = AsyncNitroping(api_key="np_live_...")
+    result = await np.notifications.send(
+        title="Hello",
+        body="World",
+        target={"all": True},
+    )
+    print(result)
+
+asyncio.run(main())
+```
+
+## API reference
+
+### `Nitroping(api_key=None, *, base_url=..., timeout=30.0, user_agent=None)`
+
+Creates a synchronous server-side client. `api_key` falls back to the
+`NITROPING_API_KEY` environment variable when omitted.
+
+| Argument     | Default                    | Notes                                 |
+| ------------ | -------------------------- | ------------------------------------- |
+| `api_key`    | `$NITROPING_API_KEY`       | Secret key, format `np_...`.          |
+| `base_url`   | `"https://nitroping.dev"`  | Override for self-hosted / staging.   |
+| `timeout`    | `30.0` seconds             | Per-request socket timeout.           |
+| `user_agent` | `"nitroping-python/0.1.0"` | Sent on every request.                |
+
+### `np.notifications.send(*, target, title=None, body=None, ..., idempotency_key=None)`
+
+Enqueues a notification. Returns `{"id": str, "status": str}` (`NotificationResult`).
+Raises `ApiError` on non-2xx, carrying the server's `code`, `message`, and
+per-field `details`.
+
+```python
+np.notifications.send(
+    title="Welcome!",
+    body="Glad to have you on board.",
+    icon="https://example.com/icon.png",
+    image="https://example.com/hero.png",
+    deep_link="https://example.com/welcome",
+    data={"onboarding": True},
+    actions=[{"id": "tour", "title": "Take the tour"}],
+    target={"all": True},
+    idempotency_key="welcome-user-42",
+)
+```
+
+`target` is one of three shapes (exactly one):
+
+| Selector                       | Use when                         |
+| ------------------------------ | -------------------------------- |
+| `{"all": True}`                | Broadcast to every active device |
+| `{"device_ids": [...]}`        | Hit specific device rows         |
+| `{"user_ids": [...]}`          | Hit every device row a user owns |
+
+### `np.notifications.get(notification_id)`
+
+Fetches a previously enqueued notification by id. Returns the full row
+(including counters: `total_sent`, `total_delivered`, `total_failed`, etc.).
+
+### `np.devices.register(*, platform, token, user_id=None, ...)`
+
+Registers (or updates) a device with the **secret** API key. Use this for
+iOS / Android where you control the server. Returns `{"id": str,
+"created": bool}` — `created` is `False` when an existing row matched on
+`(app_id, token, user_id)`.
+
+```python
+np.devices.register(
+    platform="ios",
+    token="apns-hex-token",
+    user_id="user-42",
+    metadata={"app_version": "2.4.1"},
+)
+```
+
+For Web Push, also pass `web_push_p256dh` and `web_push_auth` from the
+browser's `PushSubscription`.
+
+### `np.devices.deactivate(device_id)`
+
+Soft-deletes a device (`status = "inactive"`). Subsequent sends skip it.
+
+### `verify(*, body, signature, secret, tolerance=300, now=None)` — `nitroping.webhooks`
+
+Verifies the `X-Nitroping-Signature` header and returns the parsed event.
+
+```python
+from nitroping.webhooks import verify
+
+event = verify(
+    body=raw_body_bytes,
+    signature=request.headers.get("x-nitroping-signature"),
+    secret=os.environ["NITROPING_WEBHOOK_SECRET"],
+    tolerance=300,  # optional, seconds. Default 300.
+)
+```
+
+The signing scheme is HMAC-SHA256 over `"<unix>.<raw body>"`. The header
+ships as `t=<unix>, v1=<hex>` — same as Polar / Stripe. Use the raw
+request body bytes (not a re-serialized parsed dict) or the HMAC won't
+match.
+
+## Framework recipes
+
+### FastAPI
+
+```python
+from fastapi import FastAPI, Header, HTTPException, Request
+from nitroping import Nitroping
+from nitroping.errors import (
+    InvalidSignatureError,
+    MissingSignatureHeaderError,
+    TimestampOutOfRangeError,
+)
+from nitroping.webhooks import verify
+import os
+
+app = FastAPI()
+np = Nitroping(api_key=os.environ["NITROPING_API_KEY"])
+
+@app.post("/notify")
+def notify(title: str, body: str) -> dict[str, str]:
+    return np.notifications.send(
+        title=title, body=body, target={"all": True}
+    )
+
+@app.post("/webhooks/nitroping")
+async def webhook(
+    request: Request,
+    x_nitroping_signature: str | None = Header(default=None),
+) -> dict[str, str]:
+    raw = await request.body()
+    try:
+        event = verify(
+            body=raw,
+            signature=x_nitroping_signature,
+            secret=os.environ["NITROPING_WEBHOOK_SECRET"],
+        )
+    except (
+        InvalidSignatureError,
+        MissingSignatureHeaderError,
+        TimestampOutOfRangeError,
+    ):
+        raise HTTPException(status_code=400, detail="bad signature")
+    return {"received": event["id"]}
+```
+
+### Django
+
+```python
+# settings.py
+NITROPING_API_KEY = os.environ["NITROPING_API_KEY"]
+NITROPING_WEBHOOK_SECRET = os.environ["NITROPING_WEBHOOK_SECRET"]
+
+# views.py
+from django.conf import settings
+from django.http import HttpRequest, HttpResponse, HttpResponseBadRequest, JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_POST
+from nitroping import Nitroping
+from nitroping.errors import (
+    InvalidSignatureError,
+    MissingSignatureHeaderError,
+    TimestampOutOfRangeError,
+)
+from nitroping.webhooks import verify
+
+np = Nitroping(api_key=settings.NITROPING_API_KEY)
+
+@csrf_exempt
+@require_POST
+def nitroping_webhook(request: HttpRequest) -> HttpResponse:
+    try:
+        event = verify(
+            body=request.body,
+            signature=request.headers.get("X-Nitroping-Signature"),
+            secret=settings.NITROPING_WEBHOOK_SECRET,
+        )
+    except (
+        InvalidSignatureError,
+        MissingSignatureHeaderError,
+        TimestampOutOfRangeError,
+    ):
+        return HttpResponseBadRequest("bad signature")
+    # ...handle event...
+    return JsonResponse({"received": event["id"]})
+```
+
+### Flask
+
+```python
+import os
+from flask import Flask, abort, jsonify, request
+from nitroping.errors import (
+    InvalidSignatureError,
+    MissingSignatureHeaderError,
+    TimestampOutOfRangeError,
+)
+from nitroping.webhooks import verify
+
+app = Flask(__name__)
+
+@app.post("/webhooks/nitroping")
+def nitroping_webhook():
+    try:
+        event = verify(
+            body=request.get_data(),  # bytes — do NOT use request.json
+            signature=request.headers.get("X-Nitroping-Signature"),
+            secret=os.environ["NITROPING_WEBHOOK_SECRET"],
+        )
+    except (
+        InvalidSignatureError,
+        MissingSignatureHeaderError,
+        TimestampOutOfRangeError,
+    ):
+        abort(400)
+    return jsonify(received=event["id"])
+```
+
+## Errors
+
+Every error raised by the SDK extends `NitropingError`. Narrow by
+`isinstance` to handle specific cases:
+
+| Class                          | When it fires                                                                              |
+| ------------------------------ | ------------------------------------------------------------------------------------------ |
+| `NitropingError`               | Base class for every SDK error. Catch this to handle everything.                           |
+| `ApiError`                     | The server returned a non-2xx response. Has `status`, `code`, `details`.                   |
+| `NetworkError`                 | DNS / TLS / offline / timeout — the request never reached the server. Cause attached.      |
+| `InvalidSignatureError`        | `verify()` HMAC mismatch or malformed header.                                              |
+| `TimestampOutOfRangeError`     | `verify()` signature valid but `t=` outside the tolerance window.                          |
+| `MissingSignatureHeaderError`  | `verify()` called with `signature=None`.                                                   |
+
+```python
+from nitroping import Nitroping
+from nitroping.errors import ApiError, NetworkError
+
+np = Nitroping()  # reads NITROPING_API_KEY
+
+try:
+    np.notifications.send(title="Hi", body="There", target={"all": True})
+except NetworkError:
+    # transient — retry with backoff
+    ...
+except ApiError as err:
+    if err.code == "quota_exceeded":
+        print(err.details)  # {"quota": ..., "used": ..., "resets_at": ...}
+    else:
+        raise
+```
+
+## Type hints
+
+The package ships `py.typed` (PEP 561) — `mypy`, `pyright`, and `ruff` see
+the public surface as fully typed. Every request shape is a `TypedDict`:
+
+```python
+from nitroping import NotificationResult, RegisterDeviceResult, WebhookEvent
+```
+
+## Runtime support
+
+| Runtime        | Status |
+| -------------- | ------ |
+| CPython 3.10   | Yes    |
+| CPython 3.11   | Yes    |
+| CPython 3.12   | Yes    |
+| CPython 3.13   | Yes    |
+| PyPy 3.10+     | Should work (untested in CI). No C extensions. |
+
+## License
+
+[MIT](../LICENSE) — Copyright (c) 2026 productdevbook.
+
+---
+
+<p align="center">
+  <sub>
+    Built by <a href="https://github.com/productdevbook">@productdevbook</a> — <a href="https://nitroping.dev">nitroping.dev</a> · <a href="https://github.com/productdevbook/nitroping">OSS core</a>
+  </sub>
+</p>

nitroping-0.1.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+nitroping/__init__.py,sha256=ENaM_brocxzN2YZChy4F4zsIyrlZMp15r1XsHrfDJaI,1684
+nitroping/_client.py,sha256=5TP8ttg2FYBzwvvW1ZZ7tXmfEHciCknmWjW5V-hC_wY,6359
+nitroping/_devices.py,sha256=ADqLPpAdtqwqKAQGfLYguJp72pA98C4EfVDqBzgUeWY,2109
+nitroping/_http.py,sha256=k07nEuKwBGEwNWbCkIkX4cHmttPTjPG6ksBuQQuYKH0,5368
+nitroping/_notifications.py,sha256=q6ka9W7bxRPV3huXUR3nKHlZ_Y4ontcIW0dAgv2RKLk,3216
+nitroping/errors.py,sha256=h6S3Ks-HQmWih9v529hCRwejA1YqpY5SVnwU_EJBlGk,3485
+nitroping/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nitroping/types.py,sha256=cX9XxTiEOY6dYzvPf2i0VxXnzP6O54ZG09jljs-BPEw,2493
+nitroping/webhooks.py,sha256=-WhVyhbR0wyK6LcrWGwTSzlhHXtuzvNSNxZZyvaFXXg,5131
+nitroping-0.1.3.dist-info/METADATA,sha256=Xk6YvXu3mlWk5EOnXlPxjDGfGzvaWi2KzPuSXjtPp30,14318
+nitroping-0.1.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+nitroping-0.1.3.dist-info/RECORD,,

nitroping-0.1.3.dist-info/WHEEL

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