stubfetch 0.1.0__py3-none-any.whl

stubfetch/__init__.py

@@ -0,0 +1,23 @@
+from stubfetch.ghost_env import GhostEnv, GhostEnvConfig, Provider
+from stubfetch.export import export_recording_json, export_recording_markdown, export_har
+from stubfetch.eval_runner import run_eval, define_scenario
+from stubfetch.replay import ReplayFixture
+from stubfetch.presets import anthropic, github, postgres, s3, slack, stripe
+
+__all__ = [
+    "GhostEnv",
+    "GhostEnvConfig",
+    "Provider",
+    "github",
+    "stripe",
+    "postgres",
+    "s3",
+    "slack",
+    "anthropic",
+    "export_recording_json",
+    "export_recording_markdown",
+    "export_har",
+    "run_eval",
+    "define_scenario",
+    "ReplayFixture",
+]

stubfetch/eval_runner.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any, Callable, TypedDict
+
+from stubfetch.ghost_env import GhostEnv, GhostEnvConfig
+
+
+class Scenario(TypedDict, total=False):
+    name: str
+    config: GhostEnvConfig
+    run: Callable[[GhostEnv], None]
+    assert_: Callable[[GhostEnv], None]
+
+
+def define_scenario(**kwargs: Any) -> dict[str, Any]:
+    return kwargs
+
+
+def run_eval(scenarios: list[dict[str, Any]]) -> dict[str, Any]:
+    results: list[dict[str, Any]] = []
+    for s in scenarios:
+        env = GhostEnv(s["config"])
+        try:
+            s["run"](env)
+            check = s.get("check")
+            if check:
+                check(env)
+            results.append({"name": s["name"], "ok": True})
+        except Exception as e:  # noqa: BLE001
+            results.append({"name": s["name"], "ok": False, "error": str(e)})
+    ok = sum(1 for r in results if r["ok"])
+    return {"results": results, "pass_rate": ok / max(len(results), 1)}

stubfetch/export.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from stubfetch.recorder import CallRecord
+
+
+def export_recording_json(calls: list[CallRecord]) -> str:
+    return json.dumps([c.__dict__ for c in calls], indent=2)
+
+
+def export_recording_markdown(calls: list[CallRecord]) -> str:
+    lines = ["# stubfetch recording", ""]
+    for c in calls:
+        lines.append(f"## {c.provider} {c.method} {c.url}")
+        lines.append(f"- status: {c.response_status}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def export_har(calls: list[CallRecord], title: str = "stubfetch") -> str:
+    entries = []
+    for c in calls:
+        entries.append(
+            {
+                "request": {"method": c.method, "url": c.url},
+                "response": {"status": c.response_status, "content": {"text": str(c.response_body)}},
+            }
+        )
+    return json.dumps({"log": {"version": "1.2", "creator": {"name": title}, "entries": entries}}, indent=2)

stubfetch/ghost_env.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import json
+import re
+import time
+from typing import Any, Callable, TypedDict
+
+from stubfetch.recorder import Recorder
+from stubfetch.seed import mulberry32
+from stubfetch.world import WorldState
+
+
+class Provider(TypedDict, total=False):
+    name: str
+    seed: Callable[[WorldState, Callable[[], float]], None]
+    handle: Callable[[str, str, Any, WorldState], tuple[int, str] | None]
+
+
+class GhostEnvConfig(TypedDict, total=False):
+    seed: int
+    providers: list[Provider]
+    chaos: dict[str, Any]
+
+
+class GhostEnv:
+    def __init__(self, config: GhostEnvConfig) -> None:
+        self.world = WorldState()
+        self._recorder = Recorder()
+        self._providers = config["providers"]
+        self._chaos = config.get("chaos") or {}
+        self._rng = mulberry32(int(config.get("seed", 1)))
+        self._snap: str | None = None
+        for p in self._providers:
+            if p.get("seed"):
+                p["seed"](self.world, self._rng)
+
+    def reset(self) -> None:
+        if self._snap is None:
+            self._recorder.clear()
+            self.world.restore("{}")
+            for p in self._providers:
+                if p.get("seed"):
+                    p["seed"](self.world, self._rng)
+            return
+        self.world.restore(self._snap)
+        self._recorder.clear()
+
+    def snapshot(self) -> str:
+        self._snap = self.world.snapshot()
+        return self._snap
+
+    def restore(self, data: str) -> None:
+        self.world.restore(data)
+
+    def fetch(self, url: str, method: str = "GET", body: str | None = None) -> tuple[int, str]:
+        parsed_body: Any = None
+        if body:
+            try:
+                parsed_body = json.loads(body)
+            except json.JSONDecodeError:
+                parsed_body = body
+        start = time.perf_counter()
+        matched = "unknown"
+
+        lat = float(self._chaos.get("min_latency_ms", 0) or 0)
+        if lat:
+            time.sleep(lat / 1000.0)
+        fr = float(self._chaos.get("failure_rate", 0) or 0)
+        if fr and self._rng() < fr:
+            self._recorder.record(
+                provider="error",
+                method=method,
+                url=url,
+                request_body=parsed_body,
+                response_status=500,
+                response_body="chaos",
+                duration_ms=(time.perf_counter() - start) * 1000,
+            )
+            raise RuntimeError("stubfetch chaos")
+
+        status = 500
+        text = ""
+        try:
+            for p in self._providers:
+                h = p.get("handle")
+                if not h:
+                    continue
+                res = h(url, method.upper(), parsed_body, self.world)
+                if res:
+                    matched = p["name"]
+                    status, text = res
+                    break
+            else:
+                raise RuntimeError(f"stubfetch: no provider matched {method} {url}")
+        except Exception as e:  # noqa: BLE001
+            self._recorder.record(
+                provider="error",
+                method=method,
+                url=url,
+                request_body=parsed_body,
+                response_status=500,
+                response_body=str(e),
+                duration_ms=(time.perf_counter() - start) * 1000,
+            )
+            raise
+
+        duration = (time.perf_counter() - start) * 1000
+        try:
+            parsed_resp = json.loads(text)
+        except json.JSONDecodeError:
+            parsed_resp = text
+        self._recorder.record(
+            provider=matched,
+            method=method,
+            url=url,
+            request_body=parsed_body,
+            response_status=status,
+            response_body=parsed_resp,
+            duration_ms=duration,
+        )
+        return status, text
+
+    def calls(self, provider: str | None = None):
+        return self._recorder.filter(provider)
+
+    def was_called(self, provider: str, **kwargs: Any) -> bool:
+        method = kwargs.get("method")
+        path_includes = kwargs.get("path_includes")
+        for c in self.calls(provider):
+            if method and c.method != method:
+                continue
+            if path_includes and path_includes not in c.url:
+                continue
+            return True
+        return False
+
+    def db(self, _name: str = "postgres"):
+        world = self.world
+
+        class Db:
+            @staticmethod
+            def query(sql: str, params: list[Any] | None = None):
+                params = params or []
+                m = re.search(r"FROM\s+(\w+)", sql, re.I)
+                table = (m.group(1).lower() if m else "unknown")
+                rows = world.list(f"pg:{table}")
+                return {"rows": rows, "row_count": len(rows)}
+
+        return Db()

stubfetch/presets.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Callable
+from urllib.parse import parse_qs, urlparse
+
+from stubfetch.world import WorldState
+
+
+def _next_github_id(world: WorldState) -> int:
+    xs = world.list("github_issue")
+    return max((int(x.get("id", 0)) for x in xs), default=0) + 1
+
+
+def github(config: dict[str, Any]) -> dict[str, Any]:
+    issues = config.get("issues") or []
+
+    def seed(world: WorldState, rng: Callable[[], float]) -> None:
+        for i, it in enumerate(issues, start=1):
+            rid = _next_github_id(world)
+            world.set(
+                "github_issue",
+                f"{it['repo']}#{i}",
+                {
+                    "id": rid,
+                    "number": i,
+                    "repo": it["repo"],
+                    "title": it["title"],
+                    "body": it.get("body", ""),
+                    "state": it.get("state", "open"),
+                    "labels": it.get("labels", []),
+                },
+            )
+        rng()
+
+    def handle(url: str, method: str, body: Any, world: WorldState):
+        p = urlparse(url).path
+        m = re.match(r"^/repos/([^/]+)/([^/]+)/issues/?$", p)
+        if m and method == "GET":
+            prefix = f"{m.group(1)}/{m.group(2)}"
+            data = [x for x in world.list("github_issue") if x.get("repo") == prefix]
+            return (200, json.dumps(data))
+        if m and method == "POST":
+            repo = f"{m.group(1)}/{m.group(2)}"
+            payload = json.loads(body) if isinstance(body, str) else (body or {})
+            num = len([x for x in world.list("github_issue") if x.get("repo") == repo]) + 1
+            rid = _next_github_id(world)
+            issue = {
+                "id": rid,
+                "number": num,
+                "title": payload.get("title", "untitled"),
+                "body": payload.get("body", ""),
+                "state": "open",
+                "labels": [],
+                "repo": repo,
+            }
+            world.set("github_issue", f"{repo}#{num}", issue)
+            public = {k: v for k, v in issue.items() if k != "repo"}
+            return (201, json.dumps(public))
+        return None
+
+    return {"name": "github", "seed": seed, "handle": handle}
+
+
+def stripe(config: dict[str, Any]) -> dict[str, Any]:
+    customers = config.get("customers") or []
+
+    def seed(world: WorldState, rng: Callable[[], float]) -> None:
+        for i, c in enumerate(customers, start=1):
+            cid = c.get("id") or f"cus_{i}"
+            world.set("stripe_customer", cid, {"id": cid, "email": c["email"], "object": "customer"})
+        rng()
+
+    def handle(url: str, method: str, _body: Any, world: WorldState):
+        p = urlparse(url).path
+        if method == "GET" and p.rstrip("/") == "/v1/customers":
+            data = world.list("stripe_customer")
+            return (200, json.dumps({"object": "list", "data": data, "has_more": False}))
+        return None
+
+    return {"name": "stripe", "seed": seed, "handle": handle}
+
+
+def postgres(config: dict[str, Any]) -> dict[str, Any]:
+    tables = config.get("tables") or {}
+
+    def seed(world: WorldState, rng: Callable[[], float]) -> None:
+        for table, rows in tables.items():
+            for i, row in enumerate(rows):
+                rid = str(row.get("id", i))
+                world.set(f"pg:{table}", rid, dict(row))
+        rng()
+
+    return {"name": "postgres", "seed": seed, "handle": None}
+
+
+def s3(config: dict[str, Any]) -> dict[str, Any]:
+    objects = config.get("objects") or []
+
+    def norm_key(k: str) -> str:
+        return k.lstrip("/")
+
+    def seed(world: WorldState, rng: Callable[[], float]) -> None:
+        for o in objects:
+            b = str(o["bucket"])
+            k = norm_key(str(o["key"]))
+            world.set(
+                "s3:object",
+                f"{b}/{k}",
+                {
+                    "bucket": b,
+                    "key": k,
+                    "body": str(o.get("body", "")),
+                    "etag": str(o.get("etag", f'"{b}-{k}"')),
+                },
+            )
+        rng()
+
+    def handle(url: str, method: str, _body: Any, world: WorldState) -> tuple[int, str] | None:
+        if method != "GET":
+            return None
+        u = urlparse(url)
+        path = u.path.rstrip("/") or "/"
+        h = u.hostname or ""
+
+        vh = re.match(r"^([^.]+)\.s3[.-][^/]+\.amazonaws\.com$", h, re.I)
+        if vh:
+            bucket = vh.group(1)
+            key = norm_key(path[1:] if path.startswith("/") else path)
+            if not key:
+                return None
+            rec = world.get("s3:object", f"{bucket}/{key}")
+            if not rec:
+                return (404, "Not Found")
+            return (200, str(rec.get("body", "")))
+
+        path_style = "amazonaws.com" in h and (h == "s3.amazonaws.com" or h.startswith("s3."))
+        if path_style:
+            parts = [p for p in path.split("/") if p]
+            if not parts:
+                return None
+            bucket = parts[0]
+            qs = parse_qs(u.query)
+            lt = (qs.get("list-type") or [None])[0]
+            if len(parts) == 1 and lt == "2":
+                prefix = (qs.get("prefix") or [""])[0]
+                contents: list[dict[str, Any]] = []
+                for o in world.list("s3:object"):
+                    if o.get("bucket") != bucket:
+                        continue
+                    kk = str(o.get("key", ""))
+                    if not kk.startswith(prefix):
+                        continue
+                    contents.append(
+                        {
+                            "Key": kk,
+                            "Size": len(str(o.get("body", "")).encode("utf-8")),
+                            "ETag": o.get("etag"),
+                        }
+                    )
+                payload = {
+                    "Name": bucket,
+                    "KeyCount": len(contents),
+                    "IsTruncated": False,
+                    "Contents": contents,
+                }
+                return (200, json.dumps(payload))
+            if len(parts) < 2:
+                return None
+            key = norm_key("/".join(parts[1:]))
+            rec = world.get("s3:object", f"{bucket}/{key}")
+            if not rec:
+                return (404, "Not Found")
+            return (200, str(rec.get("body", "")))
+        return None
+
+    return {"name": "s3", "seed": seed, "handle": handle}
+
+
+def slack(config: dict[str, Any] | None = None) -> dict[str, Any]:
+    cfg = config or {}
+    bot = str(cfg.get("bot_user_id", "UFAKEBOT"))
+
+    def seed(_world: WorldState, rng: Callable[[], float]) -> None:
+        rng()
+
+    def handle(url: str, method: str, body: Any, _world: WorldState) -> tuple[int, str] | None:
+        u = urlparse(url)
+        h = u.hostname or ""
+        if not h.endswith("slack.com"):
+            return None
+        p = u.path.rstrip("/") or "/"
+        if p == "/api/auth.test" and method in ("GET", "POST"):
+            return (
+                200,
+                json.dumps(
+                    {
+                        "ok": True,
+                        "url": "https://acme.slack.com/",
+                        "team": "acme",
+                        "user": bot,
+                        "team_id": "T0001",
+                        "user_id": bot,
+                    }
+                ),
+            )
+        if p == "/api/chat.postMessage" and method == "POST":
+            text = ""
+            try:
+                payload = json.loads(body) if isinstance(body, str) else (body or {})
+                text = f'{payload.get("channel", "")}:{payload.get("text", "")}'
+            except (json.JSONDecodeError, TypeError):
+                text = ""
+            ts = "1234567890.000100"
+            return (
+                200,
+                json.dumps(
+                    {
+                        "ok": True,
+                        "channel": "C0001",
+                        "ts": ts,
+                        "message": {"user": bot, "type": "message", "text": text},
+                    }
+                ),
+            )
+        return None
+
+    return {"name": "slack", "seed": seed, "handle": handle}
+
+
+def anthropic(config: dict[str, Any] | None = None) -> dict[str, Any]:
+    cfg = config or {}
+    texts = list(cfg.get("texts") or ["Hello from fake Claude"])
+    state = {"i": 0}
+
+    def seed(_world: WorldState, rng: Callable[[], float]) -> None:
+        state["i"] = 0
+        rng()
+
+    def handle(url: str, method: str, _body: Any, _world: WorldState) -> tuple[int, str] | None:
+        u = urlparse(url)
+        if "api.anthropic.com" not in (u.hostname or ""):
+            return None
+        if method != "POST" or "/v1/messages" not in u.path:
+            return None
+        i = state["i"]
+        state["i"] = i + 1
+        text = texts[i % len(texts)]
+        payload = {
+            "id": f"msg_{i}",
+            "type": "message",
+            "role": "assistant",
+            "model": str(cfg.get("model", "claude-3-5-sonnet-20241022")),
+            "content": [{"type": "text", "text": text}],
+            "stop_reason": "end_turn",
+            "usage": {"input_tokens": 1, "output_tokens": 1},
+        }
+        return (200, json.dumps(payload))
+
+    return {"name": "anthropic", "seed": seed, "handle": handle}

stubfetch/recorder.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class CallRecord:
+    id: str
+    provider: str
+    method: str
+    url: str
+    request_body: Any
+    response_status: int
+    response_body: Any
+    duration_ms: float
+
+
+class Recorder:
+    def __init__(self) -> None:
+        self._calls: list[CallRecord] = []
+        self._seq = 0
+
+    def record(self, **kwargs: Any) -> None:
+        self._seq += 1
+        self._calls.append(CallRecord(id=f"c{self._seq}", **kwargs))
+
+    def all(self) -> list[CallRecord]:
+        return list(self._calls)
+
+    def filter(self, provider: str | None = None) -> list[CallRecord]:
+        if not provider:
+            return self.all()
+        return [c for c in self._calls if c.provider == provider]
+
+    def clear(self) -> None:
+        self._calls.clear()
+        self._seq = 0

stubfetch/replay.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from stubfetch.recorder import CallRecord
+
+
+class ReplayFixture:
+    def __init__(self, calls: list[dict[str, Any]]) -> None:
+        self._calls = calls
+        self._idx = 0
+
+    @classmethod
+    def from_json(cls, raw: str) -> ReplayFixture:
+        data = json.loads(raw)
+        return cls(data)
+
+    def next_response(self) -> tuple[int, str] | None:
+        if self._idx >= len(self._calls):
+            return None
+        c = self._calls[self._idx]
+        self._idx += 1
+        body = c.get("response_body")
+        text = body if isinstance(body, str) else json.dumps(body)
+        return int(c.get("response_status", 200)), text
+
+    def reset(self) -> None:
+        self._idx = 0

stubfetch/seed.py

@@ -0,0 +1,10 @@
+def mulberry32(seed: int):
+    def _rng() -> float:
+        nonlocal seed
+        seed = (seed + 0x6D2B79F5) & 0xFFFFFFFF
+        t = seed
+        t = (t ^ (t >> 15)) * (t | 1) & 0xFFFFFFFF
+        t ^= t + ((t ^ (t >> 7)) * (t | 61)) & 0xFFFFFFFF
+        return ((t ^ (t >> 14)) & 0xFFFFFFFF) / 4294967296.0
+
+    return _rng

stubfetch/world.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+class WorldState:
+    def __init__(self) -> None:
+        self._entities: dict[str, dict[str, dict[str, Any]]] = {}
+
+    def list(self, typ: str) -> list[dict[str, Any]]:
+        return list(self._entities.get(typ, {}).values())
+
+    def get(self, typ: str, id_: str) -> dict[str, Any] | None:
+        return self._entities.get(typ, {}).get(id_)
+
+    def set(self, typ: str, id_: str, value: dict[str, Any]) -> None:
+        self._entities.setdefault(typ, {})[id_] = value
+
+    def snapshot(self) -> str:
+        return json.dumps(self._entities)
+
+    def restore(self, data: str) -> None:
+        self._entities = json.loads(data) if data else {}

stubfetch-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: stubfetch
+Version: 0.1.0
+Summary: Deterministic fake APIs for AI agent tests
+Project-URL: Homepage, https://slaps.dev/stubfetch
+Project-URL: Documentation, https://slaps.dev/docs/stubfetch/
+Project-URL: Repository, https://github.com/vgulerianb/stubfetch
+Project-URL: Bug Tracker, https://github.com/vgulerianb/stubfetch/issues
+Author: slaps.dev
+License-Expression: Apache-2.0
+Keywords: agents,ai,anthropic,deterministic,e2e,fetch,github,http,integration-testing,mock,openai,stripe,testing
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# stubfetch
+
+**Deterministic, in-process fake HTTP APIs** for testing agents and tools. Swap real network calls for canned **GitHub**, **Stripe**, **Postgres-shaped** data, **OpenAI** / **Anthropic**-style LLM JSON, **S3**-like objects, **Slack** Web API responses—while **recording** traffic, exporting **JSON / Markdown / HAR**, running **eval scenarios**, and optionally injecting **chaos** (latency, random failures).
+
+Same ideas in **TypeScript** (npm) and **Python** (PyPI / local install).
+
+---
+
+## Install
+
+### JavaScript / TypeScript (npm)
+
+```bash
+npm install stubfetch
+```
+
+Requires **Node.js ≥ 18**. No runtime npm dependencies.
+
+### Python
+
+```bash
+pip install stubfetch
+```
+
+From a clone (editable):
+
+```bash
+pip install -e ./python
+```
+
+Requires **Python ≥ 3.10**.
+
+---
+
+## Quick start
+
+### TypeScript
+
+```ts
+import { GhostEnv, github, exportRecordingJSON } from "stubfetch";
+
+const env = new GhostEnv({
+  seed: 42,
+  providers: [github({ issues: [{ repo: "acme/api", title: "Bug" }] })],
+});
+
+const res = await env.fetch("https://api.github.com/repos/acme/api/issues");
+console.log(await res.json());
+console.log(exportRecordingJSON(env.calls()));
+```
+
+### Python
+
+```python
+from stubfetch import GhostEnv, github, export_recording_json
+
+env = GhostEnv(
+    {"seed": 1, "providers": [github({"issues": [{"repo": "acme/api", "title": "Bug"}]})]}
+)
+status, text = env.fetch("https://api.github.com/repos/acme/api/issues")
+assert status == 200
+print(export_recording_json(env.calls()))
+```
+
+---
+
+## Features
+
+| Area | What you get |
+|------|----------------|
+| **Presets** | GitHub issues, Stripe customers, Postgres `db().query()`, OpenAI chat, Anthropic messages, S3 GET/list, Slack `auth.test` / `chat.postMessage` |
+| **`GhostEnv.fetch`** | Same shape as `globalThis.fetch`; routes to the first matching provider |
+| **Recording** | `calls()`, `wasCalled()`, `exportRecordingJSON` / `Markdown` / `HAR` |
+| **Eval** | `runEval` + `defineScenario` for scripted agent tests |
+| **Replay** | `ReplayFixture` replays canned responses in order |
+| **Chaos** | `chaos: { minLatencyMs, failureRate }` on config |
+
+---
+
+## Documentation
+
+Hosted on **[slaps.dev](https://slaps.dev)**:
+
+| Doc | Contents |
+|-----|----------|
+| [Overview](https://slaps.dev/docs/stubfetch/) | Product summary and doc index |
+| [Getting started](https://slaps.dev/docs/stubfetch/getting-started) | Providers, `fetch`, recording |
+| [Use cases](https://slaps.dev/docs/stubfetch/use-cases) | Agents, agentpad, eval patterns |
+| [Presets](https://slaps.dev/docs/stubfetch/presets) | URLs, config shapes, matching rules |
+| [API reference](https://slaps.dev/docs/stubfetch/api-reference) | `GhostEnv`, `Provider`, eval, replay, exports |
+| [Testing & chaos](https://slaps.dev/docs/stubfetch/testing-and-chaos) | `runEval`, chaos options, failure recording |
+| [Python notes](https://slaps.dev/docs/stubfetch/python) | Node vs Python differences |
+
+---
+
+## License
+
+Apache-2.0

stubfetch-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+stubfetch/__init__.py,sha256=Vhcg4NppzSz6uAY7HMLu5_X5gtOuY4-ZSNToqyZLccg,630
+stubfetch/eval_runner.py,sha256=hRU2OBj0CuiY9gGWLysnNM_RqQb16_119nPA1DwTNvU,961
+stubfetch/export.py,sha256=AzCq5llsvY1nkCpiXgKiODFVXLNbG7AuBb1Lkfuf8S8,980
+stubfetch/ghost_env.py,sha256=mdo5qz0sWIfPabmU4F2AI6dlQgLNaZEutcnpnagLvG0,4763
+stubfetch/presets.py,sha256=x--4lAxGBS3BBGGQ5ZBMFqNifWmFYX_PKuPd7WDhOdA,9332
+stubfetch/recorder.py,sha256=QaSYUoKt-1bq8amwAFYUKJiu5R5BVWktI1ZUFNdBEp4,875
+stubfetch/replay.py,sha256=97QrQ0Z3HBKn78o982Xcr5n0cNPcSv5CxQhkJjwo-fU,766
+stubfetch/seed.py,sha256=FkmQbSA7uyk_8oA2mQgkdosn8zvT2jGwGmpImsx-edg,326
+stubfetch/world.py,sha256=2idRkPSMcx1yyKp-XTi9_84GM2rHpAhlqS_CqBOCIF0,721
+stubfetch-0.1.0.dist-info/METADATA,sha256=NMykI29E1YVlcQGm3Fgj9cQlHy2yPiREL6p8EXMqP4Y,3611
+stubfetch-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+stubfetch-0.1.0.dist-info/RECORD,,

stubfetch-0.1.0.dist-info/WHEEL

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