noburn 0.1.0__py3-none-any.whl

noburn/__init__.py

@@ -0,0 +1,4 @@
+from .guard import NoburnGuard, CheckResult, NoburnAuthError, NoburnTimeoutError
+
+__all__ = ["NoburnGuard", "CheckResult", "NoburnAuthError", "NoburnTimeoutError"]
+__version__ = "0.1.0"

noburn/guard.py

@@ -0,0 +1,569 @@
+from __future__ import annotations
+
+import re
+import time
+import json
+import queue
+import socket
+import threading
+import urllib.request
+import urllib.error
+from dataclasses import dataclass, field
+from typing import Any
+
+DEFAULT_BASE_URL = "https://noburn.dev"
+RULES_TTL_SECONDS = 60
+_MAX_EVENT_QUEUE = 1000
+_MAX_EVENT_RETRIES = 3
+
+_PRICING: list[tuple[str, float, float]] = [
+    ("gpt-4o-mini",       0.15,   0.60),
+    ("gpt-4o",            2.50,  10.00),
+    ("gpt-4-turbo",      10.00,  30.00),
+    ("gpt-4",            30.00,  60.00),
+    ("gpt-3.5-turbo",     0.50,   1.50),
+    ("o3-mini",           1.10,   4.40),
+    ("o1-mini",           3.00,  12.00),
+    ("o1",               15.00,  60.00),
+    ("claude-haiku",      0.80,   4.00),
+    ("claude-sonnet",     3.00,  15.00),
+    ("claude-opus",      15.00,  75.00),
+    ("gemini-2.0-flash",  0.10,   0.40),
+    ("gemini-1.5-flash",  0.075,  0.30),
+    ("gemini-1.5-pro",    1.25,   5.00),
+    ("gemini-1.0-pro",    0.50,   1.50),
+    ("deepseek",          0.14,   0.28),
+    ("mistral-large",     2.00,   6.00),
+    ("mistral-small",     0.20,   0.60),
+    ("llama-3",           0.20,   0.20),
+]
+
+_OP_RE = re.compile(r"^(>=|<=|>|<|==?)\s*([0-9.]+)$")
+
+
+def _estimate_cost(model: str, tokens_in: int, tokens_out: int) -> float:
+    lower = model.lower()
+    entry = next((p for p in _PRICING if lower.startswith(p[0])), None)
+    if entry is None:
+        entry = next((p for p in _PRICING if p[0] in lower), None)
+    if entry is None and lower.startswith("claude"):
+        for family in ("haiku", "sonnet", "opus"):
+            if family in lower:
+                entry = next((p for p in _PRICING if p[0] == f"claude-{family}"), None)
+                if entry:
+                    break
+    if entry is None:
+        return 0.0
+    return (tokens_in * entry[1] + tokens_out * entry[2]) / 1_000_000
+
+
+def _eval_operator(condition_value: str, runtime_value: float) -> bool:
+    m = _OP_RE.match(condition_value.strip())
+    if not m:
+        return False
+    op, num_str = m.group(1), m.group(2)
+    threshold = float(num_str)
+    return {
+        ">=": runtime_value >= threshold,
+        "<=": runtime_value <= threshold,
+        ">":  runtime_value >  threshold,
+        "<":  runtime_value <  threshold,
+        "=":  runtime_value == threshold,
+        "==": runtime_value == threshold,
+    }.get(op, False)
+
+
+def _matches(
+    when: dict[str, str],
+    context: dict[str, str],
+    numerics: dict[str, float],
+) -> bool:
+    for key, value in when.items():
+        if key in numerics:
+            if not _eval_operator(value, numerics[key]):
+                return False
+        elif context.get(key) != value:
+            return False
+    return True
+
+
+# ─── Errors ───────────────────────────────────────────────────────────────────
+
+class NoburnAuthError(Exception):
+    """Raised when the SDK key is invalid or unauthorised."""
+
+
+class NoburnTimeoutError(Exception):
+    """Raised when the noburn API does not respond within the timeout."""
+
+
+# ─── Result types ─────────────────────────────────────────────────────────────
+
+@dataclass
+class CheckResult:
+    blocked: bool
+    block_reason: str | None
+    forced_model_tier: str | None  # 'small' | 'big' | None
+    spend_usd: float
+    budget_cap_usd: float | None
+    remaining_usd: float | None
+    user_spend_usd: float | None = field(default=None)
+    user_cap_usd: float | None = field(default=None)
+    user_remaining_usd: float | None = field(default=None)
+    run_spend_usd: float | None = field(default=None)
+    run_cap_usd: float | None = field(default=None)
+    run_remaining_usd: float | None = field(default=None)
+
+
+@dataclass
+class StartRunResult:
+    run_id: str
+    budget_cap_usd: float | None
+    started_at: str
+
+
+@dataclass
+class EndRunResult:
+    run_id: str
+    status: str  # 'completed' | 'budget_exceeded'
+    spend_usd: float
+    budget_cap_usd: float | None
+    started_at: str
+    ended_at: str
+
+
+# ─── NoburnGuard ─────────────────────────────────────────────────────────────
+
+class NoburnGuard:
+    """
+    Drop-in LLM spend enforcement for Python.
+
+    Usage::
+
+        guard = NoburnGuard(api_key="sk-nb-...", project_id="...", budget_cap_usd=10.0)
+
+        # Agent run with per-run budget cap
+        run = guard.start_run(budget_cap_usd=0.50)
+
+        result = guard.check(
+            model="gpt-4o",
+            estimated_tokens_in=1000,
+            estimated_tokens_out=300,
+            run_id=run.run_id,
+        )
+        if result.blocked:
+            raise RuntimeError(result.block_reason)
+
+        # ... LLM call ...
+
+        guard.record(model="gpt-4o", tokens_in=980, tokens_out=290,
+                     cost_usd=0.005, was_blocked=False, run_id=run.run_id)
+
+        guard.end_run(run.run_id)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        project_id: str,
+        budget_cap_usd: float | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 2.0,
+        on_error: str = "allow",
+    ) -> None:
+        if not api_key:
+            raise ValueError("api_key is required")
+        if not project_id:
+            raise ValueError("project_id is required")
+        if on_error not in ("allow", "block"):
+            raise ValueError("on_error must be 'allow' or 'block'")
+
+        self._api_key = api_key
+        self._project_id = project_id
+        self._budget_cap_usd = budget_cap_usd
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        # When the noburn API is unreachable and the local fallback has no
+        # opinion: 'allow' fails open (default — an outage never breaks your
+        # app); 'block' fails closed (blocks with reason 'noburn_unreachable').
+        self._on_error = on_error
+
+        self._rules: list[dict[str, Any]] = []
+        self._rules_loaded_at: float = 0.0
+        self._spend_usd: float = 0.0
+        # Guards _spend_usd / _reserved_usd against concurrent threads.
+        self._lock = threading.Lock()
+        # In-flight cost reserved by local-fallback checks, not yet recorded.
+        self._reserved_usd: float = 0.0
+        # Single background worker drains a bounded retry queue, so record()
+        # never blocks, never loses an event to a transient blip, and never
+        # spawns an unbounded number of threads under load.
+        self._event_queue: "queue.Queue[tuple[bytes, int]]" = queue.Queue(maxsize=_MAX_EVENT_QUEUE)
+        self._dropped_events: int = 0
+        self._worker_started = False
+        self._worker_lock = threading.Lock()
+
+    # ─── Agent runs ───────────────────────────────────────────────────────────
+
+    def start_run(
+        self,
+        budget_cap_usd: float | None = None,
+        end_user_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> StartRunResult:
+        """
+        Start an agent run. Returns a StartRunResult with run_id to attach to
+        every check() and record() call in the run.
+        Raises on network or auth error — a run must be registered to proceed.
+        """
+        payload = json.dumps({
+            "project_id":    self._project_id,
+            "budget_cap_usd": budget_cap_usd,
+            "end_user_id":   end_user_id,
+            "metadata":      metadata,
+        }).encode()
+
+        req = urllib.request.Request(
+            f"{self._base_url}/api/v1/runs",
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                body = json.loads(resp.read())
+                return StartRunResult(
+                    run_id=body["run_id"],
+                    budget_cap_usd=body.get("budget_cap_usd"),
+                    started_at=body["started_at"],
+                )
+        except urllib.error.HTTPError as exc:
+            if exc.code in (401, 403):
+                raise NoburnAuthError("Invalid SDK key") from exc
+            raise
+        except (TimeoutError, socket.timeout) as exc:
+            raise NoburnTimeoutError("noburn API timed out") from exc
+        except urllib.error.URLError as exc:
+            if isinstance(exc.reason, (TimeoutError, socket.timeout)):
+                raise NoburnTimeoutError("noburn API timed out") from exc
+            raise
+
+    def end_run(self, run_id: str) -> EndRunResult | None:
+        """
+        End a run. Fire-and-forget — returns None on any network error.
+        """
+        payload = json.dumps({"project_id": self._project_id}).encode()
+        req = urllib.request.Request(
+            f"{self._base_url}/api/v1/runs/{run_id}/end",
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                body = json.loads(resp.read())
+                return EndRunResult(
+                    run_id=body["run_id"],
+                    status=body["status"],
+                    spend_usd=float(body.get("spend_usd", 0)),
+                    budget_cap_usd=body.get("budget_cap_usd"),
+                    started_at=body["started_at"],
+                    ended_at=body["ended_at"],
+                )
+        except urllib.error.HTTPError as exc:
+            if exc.code in (401, 403):
+                raise NoburnAuthError("Invalid SDK key") from exc
+            return None
+        except Exception:
+            return None
+
+    # ─── Internal ─────────────────────────────────────────────────────────────
+
+    def _refresh_rules(self) -> None:
+        if time.monotonic() - self._rules_loaded_at < RULES_TTL_SECONDS:
+            return
+
+        url = f"{self._base_url}/api/v1/policy?project_id={self._project_id}"
+        req = urllib.request.Request(
+            url,
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                body = json.loads(resp.read())
+                self._rules = body.get("rules", [])
+                self._rules_loaded_at = time.monotonic()
+        except urllib.error.HTTPError as exc:
+            if exc.code in (401, 403):
+                raise NoburnAuthError("Invalid SDK key") from exc
+        except Exception:
+            pass
+
+    def _server_check(
+        self,
+        model: str,
+        estimated_cost: float,
+        end_user_id: str | None,
+        run_id: str | None,
+        context: dict[str, str] | None,
+        tokens_in: int = 0,
+        tokens_out: int = 0,
+    ) -> CheckResult | None:
+        payload = json.dumps({
+            "project_id":           self._project_id,
+            "model":                model,
+            "end_user_id":          end_user_id,
+            "run_id":               run_id,
+            "estimated_cost_usd":   estimated_cost,
+            # Send raw token counts so the server can price the call
+            # authoritatively rather than trusting estimated_cost_usd.
+            "estimated_tokens_in":  max(0, tokens_in),
+            "estimated_tokens_out": max(0, tokens_out),
+            "context":              context,
+        }).encode()
+
+        req = urllib.request.Request(
+            f"{self._base_url}/api/v1/check",
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                body = json.loads(resp.read())
+                return CheckResult(
+                    blocked=not body["allowed"],
+                    block_reason=body.get("reason"),
+                    forced_model_tier=body.get("forced_model_tier"),
+                    spend_usd=float(body.get("project_spend_usd", 0)),
+                    budget_cap_usd=body.get("project_cap_usd"),
+                    remaining_usd=body.get("project_remaining_usd"),
+                    user_spend_usd=float(body.get("user_spend_usd", 0)),
+                    user_cap_usd=body.get("user_cap_usd"),
+                    user_remaining_usd=body.get("user_remaining_usd"),
+                    run_spend_usd=float(body.get("run_spend_usd", 0)),
+                    run_cap_usd=body.get("run_cap_usd"),
+                    run_remaining_usd=body.get("run_remaining_usd"),
+                )
+        except urllib.error.HTTPError as exc:
+            if exc.code in (401, 403):
+                raise NoburnAuthError("Invalid SDK key") from exc
+            return None
+        except Exception:
+            return None
+
+    # ─── Public API ───────────────────────────────────────────────────────────
+
+    def check(
+        self,
+        model: str,
+        estimated_tokens_in: int,
+        estimated_tokens_out: int,
+        end_user_id: str | None = None,
+        run_id: str | None = None,
+        cost_usd: float | None = None,
+        context: dict[str, str] | None = None,
+    ) -> CheckResult:
+        """
+        Check whether a planned LLM call should proceed.
+        Call this *before* every LLM API call.
+        Never raises except NoburnAuthError (bad key).
+
+        Every call hits POST /api/v1/check for a server-authoritative decision.
+        Falls back to local check if the server is unreachable.
+        """
+        # Clamp to non-negative so a bad caller can't drive the cost negative.
+        tokens_in = max(0, estimated_tokens_in)
+        tokens_out = max(0, estimated_tokens_out)
+        estimated_cost = cost_usd if cost_usd is not None else _estimate_cost(
+            model, tokens_in, tokens_out
+        )
+
+        server_result = self._server_check(
+            model, estimated_cost, end_user_id, run_id, context, tokens_in, tokens_out
+        )
+        if server_result is not None:
+            return server_result
+
+        # Server unreachable. Enforce against actual + in-flight reserved spend
+        # under a lock so concurrent fallback checks (threads) don't all pass the
+        # same pre-record budget and don't lose updates to the counter.
+        with self._lock:
+            effective = self._spend_usd + self._reserved_usd
+            spend_snapshot = self._spend_usd
+        remaining = (
+            self._budget_cap_usd - effective
+            if self._budget_cap_usd is not None else None
+        )
+        if self._on_error == "block":
+            return CheckResult(
+                blocked=True, block_reason="noburn_unreachable", forced_model_tier=None,
+                spend_usd=spend_snapshot, budget_cap_usd=self._budget_cap_usd,
+                remaining_usd=remaining,
+            )
+        utilization = (
+            effective / self._budget_cap_usd
+            if self._budget_cap_usd and self._budget_cap_usd > 0 else 0.0
+        )
+
+        try:
+            self._refresh_rules()
+        except NoburnAuthError:
+            raise
+
+        ctx: dict[str, str] = {"model": model, **(context or {})}
+        if end_user_id is not None:
+            ctx["end_user_id"] = end_user_id
+        if run_id is not None:
+            ctx["run_id"] = run_id
+        numerics = {"utilization": utilization}
+
+        blocked = False
+        block_reason: str | None = None
+        forced_tier: str | None = None
+
+        for rule in self._rules:
+            when: dict[str, str] = rule.get("when", {})
+            then: str = rule.get("then", "")
+            if not _matches(when, ctx, numerics):
+                continue
+            if then == "allow":
+                break
+            if then == "block":
+                blocked, block_reason = True, "policy_rule"
+                break
+            if then in ("force_small", "force_big"):
+                forced_tier = "small" if then == "force_small" else "big"
+                break
+
+        if not blocked and forced_tier is None and \
+                self._budget_cap_usd is not None and effective + estimated_cost > self._budget_cap_usd:
+            blocked, block_reason = True, "budget_exceeded"
+
+        # Reserve the estimated cost for any call we let through; record()
+        # releases the reservation when the actual outcome arrives.
+        if not blocked:
+            with self._lock:
+                self._reserved_usd += estimated_cost
+
+        return CheckResult(
+            blocked=blocked, block_reason=block_reason, forced_model_tier=forced_tier,
+            spend_usd=spend_snapshot, budget_cap_usd=self._budget_cap_usd,
+            remaining_usd=max(0.0, remaining or 0.0) if block_reason == "budget_exceeded" else remaining,
+        )
+
+    def record(
+        self,
+        model: str,
+        tokens_in: int,
+        tokens_out: int,
+        cost_usd: float,
+        was_blocked: bool,
+        end_user_id: str | None = None,
+        run_id: str | None = None,
+        latency_ms: int | None = None,
+        block_reason: str | None = None,
+        timestamp: str | None = None,
+    ) -> None:
+        """
+        Record the actual outcome of an LLM call. Fire-and-forget: returns
+        immediately and never raises — the event is queued and delivered (with
+        retry) by a single background worker, so it never adds latency, never
+        loses an event to a transient blip, and never spawns a thread per call.
+        """
+        with self._lock:
+            if not was_blocked:
+                self._spend_usd += cost_usd
+            # Release the reservation made by the corresponding fallback check().
+            self._reserved_usd = max(0.0, self._reserved_usd - cost_usd)
+
+        payload = json.dumps({
+            "project_id":   self._project_id,
+            "model":        model,
+            "tokens_in":    tokens_in,
+            "tokens_out":   tokens_out,
+            "cost_usd":     cost_usd,
+            "was_blocked":  was_blocked,
+            "block_reason": block_reason,
+            "end_user_id":  end_user_id,
+            "run_id":       run_id,
+            "latency_ms":   latency_ms,
+            "timestamp":    timestamp or time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        }).encode()
+
+        self._enqueue_event(payload)
+
+    @property
+    def dropped_event_count(self) -> int:
+        """Events dropped via queue overflow or retry exhaustion."""
+        return self._dropped_events
+
+    def flush(self, timeout: float | None = None) -> None:
+        """Block until the event queue is drained. Call before process exit."""
+        try:
+            # queue.join() has no timeout; approximate by polling unfinished tasks.
+            deadline = None if timeout is None else time.monotonic() + timeout
+            while self._event_queue.unfinished_tasks:
+                if deadline is not None and time.monotonic() > deadline:
+                    return
+                time.sleep(0.01)
+        except Exception:
+            pass
+
+    def _enqueue_event(self, payload: bytes) -> None:
+        self._ensure_worker()
+        try:
+            self._event_queue.put_nowait((payload, 0))
+        except queue.Full:
+            self._dropped_events += 1
+
+    def _ensure_worker(self) -> None:
+        with self._worker_lock:
+            if self._worker_started:
+                return
+            self._worker_started = True
+            threading.Thread(target=self._worker, daemon=True).start()
+
+    def _worker(self) -> None:
+        while True:
+            payload, attempt = self._event_queue.get()
+            try:
+                if not self._send_event(payload):
+                    if attempt + 1 < _MAX_EVENT_RETRIES:
+                        time.sleep(0.2 * (2 ** attempt))
+                        try:
+                            self._event_queue.put_nowait((payload, attempt + 1))
+                        except queue.Full:
+                            self._dropped_events += 1
+                    else:
+                        self._dropped_events += 1
+            finally:
+                self._event_queue.task_done()
+
+    def _send_event(self, payload: bytes) -> bool:
+        req = urllib.request.Request(
+            f"{self._base_url}/api/v1/events",
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout):
+                return True
+        except urllib.error.HTTPError as exc:
+            # 4xx won't succeed on retry (bad key / bad body) — stop retrying.
+            return 400 <= exc.code < 500
+        except Exception:
+            return False

noburn-0.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: noburn
+Version: 0.1.0
+Summary: Hard LLM spend enforcement for Python — pre-call budget checks and per-user metering.
+Project-URL: Homepage, https://noburn.dev
+Project-URL: Documentation, https://noburn.dev/docs
+Project-URL: Repository, https://github.com/orvi2014/noburn
+License: MIT
+Keywords: ai,anthropic,budget,cost-control,langchain,llm,openai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# noburn
+
+Hard LLM spend enforcement for Python — pre-call budget checks and per-user metering.
+
+Check a planned LLM call against project-, per-user-, and per-run budget caps
+*before* you make it, then record what it actually cost.
+
+## Install
+
+```bash
+pip install noburn
+```
+
+Requires Python ≥ 3.9. No third-party dependencies. Ships type hints (`py.typed`).
+
+## Quick start
+
+```python
+import os
+from noburn import NoburnGuard
+
+guard = NoburnGuard(
+    api_key=os.environ["NOBURN_API_KEY"],
+    project_id=os.environ["NOBURN_PROJECT_ID"],
+    budget_cap_usd=10.0,     # optional local fallback cap
+    on_error="allow",        # "allow" (default, fail-open) | "block" (fail-closed)
+)
+
+decision = guard.check(
+    model="gpt-4o",
+    estimated_tokens_in=1000,
+    estimated_tokens_out=300,
+    end_user_id="user_123",  # optional — enforces that user's cap
+)
+
+if decision.blocked:
+    raise RuntimeError(f"Blocked by noburn: {decision.block_reason}")
+
+# ... make your LLM call ...
+
+guard.record(
+    model="gpt-4o",
+    tokens_in=980,
+    tokens_out=290,
+    cost_usd=0.005,
+    was_blocked=False,
+    end_user_id="user_123",
+)
+```
+
+`record()` is fire-and-forget — it returns immediately (delivery happens on a
+background daemon thread) and never raises, so it adds no latency to your call
+path.
+
+## Agent runs
+
+Bound a single agent invocation with its own cap:
+
+```python
+run = guard.start_run(budget_cap_usd=0.5)
+
+decision = guard.check(
+    model="gpt-4o",
+    estimated_tokens_in=1000,
+    estimated_tokens_out=300,
+    run_id=run.run_id,
+)
+
+guard.record(model="gpt-4o", tokens_in=980, tokens_out=290,
+             cost_usd=0.005, was_blocked=False, run_id=run.run_id)
+
+summary = guard.end_run(run.run_id)  # EndRunResult(status=..., spend_usd=..., ...)
+```
+
+## Behavior
+
+- **`check()` never raises** except `NoburnAuthError` (bad key). Every call asks
+  the server for an authoritative decision; if the server is unreachable it
+  falls back to a local in-memory check.
+- **`on_error`** controls that fallback when nothing local blocks the call:
+  `"allow"` (default) fails open so a noburn outage never breaks your app;
+  `"block"` fails closed (`block_reason="noburn_unreachable"`).
+- **`start_run()` raises** on network/auth error (`NoburnTimeoutError` on
+  timeout) — a run must be registered before you proceed.
+
+> Note: `check()`/`start_run()` use blocking HTTP. In async apps, run them in a
+> thread executor (e.g. `await asyncio.to_thread(guard.check, ...)`).
+
+## License
+
+MIT

noburn-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+noburn/__init__.py,sha256=NztIfn9xj2NFbv6OnOQ2MSMl7LPX8_irfNBNYs8VmcM,186
+noburn/guard.py,sha256=7EwAiIS_zpov41oNvyLx7G2yaW6ljS3kkNcs6UGBgDk,21641
+noburn/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+noburn-0.1.0.dist-info/METADATA,sha256=_U26hrOUrxyJZtDomnr37RPmSaE0NVPHJgmBurW2Nu8,3385
+noburn-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+noburn-0.1.0.dist-info/RECORD,,

noburn-0.1.0.dist-info/WHEEL

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