weightspace 0.1.0__py3-none-any.whl

weightspace/sandbox.py

@@ -0,0 +1,68 @@
+"""Persistent Python namespace the LLM uses to analyse and edit weights.
+
+This is a convenience for a trusted LLM, not a security boundary: code runs
+in-process. The model object itself is never put in the namespace, so the
+only way to run the network is through the budgeted forward tools.
+"""
+
+from __future__ import annotations
+
+import ast
+import contextlib
+import io
+import signal
+import threading
+import traceback
+
+
+class SandboxTimeout(Exception):
+    pass
+
+
+class Sandbox:
+    def __init__(self, namespace: dict | None = None, *, timeout: float | None = 120, max_output: int = 12000):
+        self.ns: dict = {"__name__": "__weightspace__"}
+        self.ns.update(namespace or {})
+        self.timeout = timeout
+        self.max_output = max_output
+
+    def run(self, code: str) -> str:
+        buf = io.StringIO()
+        try:
+            tree = ast.parse(code, mode="exec")
+            last = None
+            if tree.body and isinstance(tree.body[-1], ast.Expr):
+                last = ast.Expression(tree.body.pop().value)
+            with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf), self._deadline():
+                exec(compile(tree, "<sandbox>", "exec"), self.ns)
+                if last is not None:
+                    value = eval(compile(last, "<sandbox>", "eval"), self.ns)
+                    if value is not None:
+                        print(repr(value))
+        except SandboxTimeout:
+            buf.write(f"\nTimeoutError: code ran longer than {self.timeout}s")
+        except BaseException:
+            tb = traceback.format_exc().splitlines()
+            buf.write("\n".join(l for l in tb if 'File "' not in l or "<sandbox>" in l))
+        out = buf.getvalue()
+        if len(out) > self.max_output:
+            half = self.max_output // 2
+            out = out[:half] + f"\n... [{len(out) - self.max_output:,} chars truncated] ...\n" + out[-half:]
+        return out or "(no output)"
+
+    @contextlib.contextmanager
+    def _deadline(self):
+        if not self.timeout or threading.current_thread() is not threading.main_thread():
+            yield
+            return
+
+        def handler(signum, frame):
+            raise SandboxTimeout()
+
+        old = signal.signal(signal.SIGALRM, handler)
+        signal.setitimer(signal.ITIMER_REAL, self.timeout)
+        try:
+            yield
+        finally:
+            signal.setitimer(signal.ITIMER_REAL, 0)
+            signal.signal(signal.SIGALRM, old)

weightspace/space.py

@@ -0,0 +1,319 @@
+"""A model-agnostic view of a network's weights as named numpy arrays.
+
+The LLM never sees the model object, only tensors. Edits are tracked against
+the original weights so we can report how much changed, roll back, and export
+a sparse patch.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+from collections.abc import Callable, Iterator, Mapping
+from dataclasses import dataclass, field
+
+import numpy as np
+
+
+class Store:
+    """Backend holding the live tensors. Subclasses adapt torch, HF, files..."""
+
+    def names(self) -> list[str]:
+        raise NotImplementedError
+
+    def shape(self, name: str) -> tuple[int, ...]:
+        raise NotImplementedError
+
+    def dtype(self, name: str) -> str:
+        raise NotImplementedError
+
+    def get(self, name: str) -> np.ndarray:
+        """Return a writable float array; edits to it must survive `flush`."""
+        raise NotImplementedError
+
+    def flush(self, names: list[str]) -> None:
+        """Push edits of `names` back to the underlying model, if any."""
+
+
+class NumpyStore(Store):
+    def __init__(self, tensors: Mapping[str, np.ndarray]):
+        self._t = {}
+        for k, v in tensors.items():
+            arr = np.asarray(v)
+            if not np.issubdtype(arr.dtype, np.floating):
+                arr = arr.astype(np.float32)
+            self._t[k] = arr
+        self._original_dtypes = {k: str(np.asarray(v).dtype) for k, v in tensors.items()}
+
+    def names(self):
+        return list(self._t)
+
+    def shape(self, name):
+        return tuple(self._t[name].shape)
+
+    def dtype(self, name):
+        return self._original_dtypes[name]
+
+    def get(self, name):
+        return self._t[name]
+
+
+@dataclass
+class TensorDiff:
+    name: str
+    numel: int
+    changed: int
+    l2_delta: float
+    max_abs_delta: float
+    rel_delta: float
+
+
+@dataclass
+class DiffSummary:
+    total_params: int
+    changed_params: int
+    tensors: list[TensorDiff] = field(default_factory=list)
+
+    @property
+    def fraction(self) -> float:
+        return self.changed_params / self.total_params if self.total_params else 0.0
+
+    def __str__(self) -> str:
+        if not self.tensors:
+            return "no weights changed"
+        lines = [
+            f"{self.changed_params:,} of {self.total_params:,} weights changed "
+            f"({100 * self.fraction:.4g}%) in {len(self.tensors)} tensor(s)"
+        ]
+        for t in self.tensors:
+            lines.append(
+                f"  {t.name}: {t.changed:,}/{t.numel:,} changed, "
+                f"|delta|={t.l2_delta:.4g} ({100 * t.rel_delta:.3g}% of norm), max={t.max_abs_delta:.4g}"
+            )
+        return "\n".join(lines)
+
+
+class _ReadOnly(Mapping):
+    def __init__(self, ws: WeightSpace):
+        self._ws = ws
+
+    def __getitem__(self, name):
+        arr = self._ws._store.get(name).view()
+        arr.flags.writeable = False
+        return arr
+
+    def __iter__(self):
+        return iter(self._ws.names())
+
+    def __len__(self):
+        return len(self._ws.names())
+
+    def __repr__(self):
+        return f"<read-only weights: {len(self)} tensors>"
+
+
+class _Writable(Mapping):
+    """Mapping handed to the sandbox. Touching a tensor snapshots its original."""
+
+    def __init__(self, ws: WeightSpace):
+        self._ws = ws
+
+    def __getitem__(self, name):
+        return self._ws.edit(name)
+
+    def __setitem__(self, name, value):
+        self._ws.set(name, value)
+
+    def __iter__(self):
+        return iter(self._ws.names())
+
+    def __len__(self):
+        return len(self._ws.names())
+
+    def __repr__(self):
+        return f"<writable weights: {len(self)} tensors>"
+
+
+class WeightSpace:
+    """Named float tensors with edit tracking, checkpoints and patches."""
+
+    def __init__(self, store: Store, *, on_sync: Callable[[], None] | None = None):
+        self._store = store
+        self._original: dict[str, np.ndarray] = {}
+        self._checkpoints: dict[str, dict[str, np.ndarray]] = {}
+        self._on_sync = on_sync
+        self.R = _ReadOnly(self)
+        self.W = _Writable(self)
+
+    # construction -----------------------------------------------------------------
+    @classmethod
+    def from_numpy(cls, tensors: Mapping[str, np.ndarray]) -> WeightSpace:
+        return cls(NumpyStore(tensors))
+
+    @classmethod
+    def from_torch(cls, module, **kw) -> WeightSpace:
+        from .adapters import TorchStore
+
+        return cls(TorchStore(module, **kw))
+
+    @classmethod
+    def from_hf(cls, model_or_name, **kw) -> WeightSpace:
+        from .adapters import load_hf
+
+        return cls.from_torch(load_hf(model_or_name, **kw))
+
+    @classmethod
+    def from_file(cls, path: str) -> WeightSpace:
+        from .adapters import load_file
+
+        return cls(NumpyStore(load_file(path)))
+
+    # reading ----------------------------------------------------------------------
+    def names(self, pattern: str | None = None) -> list[str]:
+        names = self._store.names()
+        if pattern:
+            names = [n for n in names if fnmatch.fnmatch(n, pattern) or pattern in n]
+        return names
+
+    def shape(self, name: str) -> tuple[int, ...]:
+        return self._store.shape(name)
+
+    def dtype(self, name: str) -> str:
+        return self._store.dtype(name)
+
+    def numel(self, name: str | None = None) -> int:
+        if name is not None:
+            return int(np.prod(self.shape(name), dtype=np.int64))
+        return sum(self.numel(n) for n in self.names())
+
+    def __getitem__(self, name: str) -> np.ndarray:
+        return self.R[name]
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._store.names()
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.names())
+
+    def __len__(self) -> int:
+        return len(self.names())
+
+    def original(self, name: str) -> np.ndarray:
+        if name in self._original:
+            return self._original[name]
+        return self.R[name]
+
+    # writing ----------------------------------------------------------------------
+    def _snapshot(self, name: str) -> None:
+        if name not in self._original:
+            if name not in self:
+                raise KeyError(f"unknown tensor {name!r}")
+            self._original[name] = self._store.get(name).copy()
+
+    def edit(self, name: str) -> np.ndarray:
+        """Return the live, writable array for `name` (in-place edits are tracked)."""
+        self._snapshot(name)
+        return self._store.get(name)
+
+    def set(self, name: str, value) -> None:
+        arr = self.edit(name)
+        value = np.asarray(value, dtype=arr.dtype)
+        if value.shape != arr.shape:
+            value = np.broadcast_to(value, arr.shape)
+        arr[...] = value
+
+    def zero_(self, pattern: str | None = None) -> None:
+        for n in self.names(pattern):
+            self.edit(n)[...] = 0
+
+    def touched(self) -> list[str]:
+        return list(self._original)
+
+    def sync(self) -> None:
+        """Write edits back into the wrapped model (before a forward pass)."""
+        self._store.flush(self.touched())
+        if self._on_sync:
+            self._on_sync()
+
+    # diff / rollback ----------------------------------------------------------------
+    def diff(self) -> DiffSummary:
+        out = DiffSummary(total_params=self.numel(), changed_params=0)
+        for name, orig in self._original.items():
+            cur = self._store.get(name)
+            delta = cur.astype(np.float64) - orig.astype(np.float64)
+            changed = int(np.count_nonzero(delta))
+            if not changed:
+                continue
+            l2 = float(np.linalg.norm(delta))
+            base = float(np.linalg.norm(orig.astype(np.float64)))
+            out.tensors.append(
+                TensorDiff(
+                    name=name,
+                    numel=int(orig.size),
+                    changed=changed,
+                    l2_delta=l2,
+                    max_abs_delta=float(np.abs(delta).max()),
+                    rel_delta=l2 / base if base else float("inf"),
+                )
+            )
+            out.changed_params += changed
+        return out
+
+    def revert(self, name: str | None = None) -> None:
+        names = [name] if name else list(self._original)
+        for n in names:
+            if n in self._original:
+                self._store.get(n)[...] = self._original[n]
+
+    def checkpoint(self, label: str) -> None:
+        self._checkpoints[label] = {n: self._store.get(n).copy() for n in self._original}
+
+    def restore(self, label: str) -> None:
+        if label not in self._checkpoints:
+            raise KeyError(f"no checkpoint {label!r}; have {list(self._checkpoints)}")
+        saved = self._checkpoints[label]
+        for n in self._original:
+            self._store.get(n)[...] = saved.get(n, self._original[n])
+
+    def checkpoints(self) -> list[str]:
+        return list(self._checkpoints)
+
+    def commit(self) -> None:
+        """Accept current weights as the new baseline."""
+        self._original.clear()
+        self._checkpoints.clear()
+
+    # patches ----------------------------------------------------------------------
+    def patch(self) -> dict[str, np.ndarray]:
+        """Sparse patch: `<name>::idx` flat indices and `<name>::val` new values."""
+        out: dict[str, np.ndarray] = {}
+        for t in self.diff().tensors:
+            cur = self._store.get(t.name).reshape(-1)
+            idx = np.flatnonzero(cur != self._original[t.name].reshape(-1))
+            out[f"{t.name}::idx"] = idx.astype(np.int64)
+            out[f"{t.name}::val"] = cur[idx].copy()
+        return out
+
+    def save_patch(self, path: str) -> None:
+        np.savez_compressed(path, **self.patch())
+
+    def apply_patch(self, patch: str | Mapping[str, np.ndarray]) -> None:
+        if isinstance(patch, str):
+            with np.load(patch) as f:
+                patch = {k: f[k] for k in f.files}
+        for key in patch:
+            if not key.endswith("::idx"):
+                continue
+            name = key[: -len("::idx")]
+            arr = self.edit(name).reshape(-1)
+            arr[patch[key]] = patch[f"{name}::val"]
+
+    def to_numpy(self) -> dict[str, np.ndarray]:
+        return {n: self._store.get(n).copy() for n in self.names()}
+
+    def save(self, path: str) -> None:
+        from .adapters import save_file
+
+        save_file(self.to_numpy(), path)
+
+    def __repr__(self) -> str:
+        return f"WeightSpace({len(self)} tensors, {self.numel():,} weights)"

weightspace/tasks.py

@@ -0,0 +1,57 @@
+"""One-call entry points: read / fix / write / improve."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from .agent import Result, Session
+from .space import WeightSpace
+
+
+def as_weightspace(model) -> WeightSpace:
+    """Wrap a WeightSpace, torch module, HF model, dict of arrays, or weights file path."""
+    if isinstance(model, WeightSpace):
+        return model
+    if isinstance(model, str):
+        return WeightSpace.from_file(model)
+    if isinstance(model, Mapping):
+        return WeightSpace.from_numpy(model)
+    try:
+        import torch
+
+        if isinstance(model, torch.nn.Module):
+            return WeightSpace.from_torch(model)
+    except ImportError:
+        pass
+    raise TypeError(f"cannot build a WeightSpace from {type(model).__name__}")
+
+
+def _run(mode, model, task, llm, text_mode=False, **kw) -> Result:
+    ws = as_weightspace(model)
+    text_kw = {k: kw.pop(k) for k in ("precision", "max_chars") if k in kw}
+    s = Session(ws, llm, mode=mode, **kw)
+    return s.run_text(task, **text_kw) if text_mode else s.run(task)
+
+
+def read(model, question: str, llm, **kw) -> Result:
+    """Answer a question about a network from its weights. Never edits."""
+    return _run("read", model, question, llm, **kw)
+
+
+def fix(model, problem: str, llm, **kw) -> Result:
+    """Find and fix the cause of a described failure by editing weights."""
+    return _run("fix", model, problem, llm, **kw)
+
+
+def write(model, spec: str, llm, *, zero_init: bool = True, **kw) -> Result:
+    """Program a network from scratch (weights zeroed first unless zero_init=False)."""
+    ws = as_weightspace(model)
+    if zero_init:
+        ws.zero_()
+        ws.commit()
+    return _run("write", ws, spec, llm, **kw)
+
+
+def improve(model, goal: str, llm, **kw) -> Result:
+    """Make a network better at a goal, usually with probes and a forward budget."""
+    return _run("improve", model, goal, llm, **kw)

weightspace-0.1.0.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.5
+Name: weightspace
+Version: 0.1.0
+Summary: Weight-space programming: let an LLM read and write neural network weights directly.
+Project-URL: Homepage, https://github.com/leofmarciano/weightspace
+Project-URL: Source, https://github.com/leofmarciano/weightspace
+Keywords: interpretability,llm,model-editing,pytorch,weights
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: all
+Requires-Dist: anthropic>=0.40; extra == 'all'
+Requires-Dist: openai>=1.40; extra == 'all'
+Requires-Dist: safetensors>=0.4; extra == 'all'
+Requires-Dist: torch>=2.1; extra == 'all'
+Requires-Dist: transformers>=4.40; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: hf
+Requires-Dist: safetensors>=0.4; extra == 'hf'
+Requires-Dist: torch>=2.1; extra == 'hf'
+Requires-Dist: transformers>=4.40; extra == 'hf'
+Provides-Extra: openai
+Requires-Dist: openai>=1.40; extra == 'openai'
+Provides-Extra: torch
+Requires-Dist: torch>=2.1; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# weightspace
+
+A small Python framework for **weight-space programming**: an LLM reads and edits a neural network's weights directly, by reasoning about what each part computes, instead of training it.
+
+Based on [Sparks of Weight-Space Programming](https://rikiyat.github.io/blog/weight-space-programming/) (Takehi, Teoh, Zhang, Khattab, 2026). This repo is the harness, not the paper's results: how well it works depends on the LLM you plug in.
+
+## What you get
+
+- **Any model.** PyTorch modules, Hugging Face models, or `.safetensors` / `.npz` / `.pt` files. The LLM only ever sees tensors, never the model object.
+- **Four tasks.** `read` (what does this network do?), `fix` (find and fix the cause of a failure), `write` (program a network from zero), `improve` (make it better at a goal).
+- **Tools for the LLM.** List, describe (norms, SVD) and read tensor slices; a persistent Python sandbox over the weights; edits, checkpoints and rollbacks.
+- **Budgeted forward passes.** You decide how the network may be run (scores, rollouts, generations, attention maps only...) by writing a `probe`, and how many times.
+- **Edit tracking.** Every run reports exactly how many weights changed, and exports a sparse patch.
+- **Text mode.** For small networks: dump every weight into the prompt and get one reply back, no tools (like the paper's first experiments).
+- **Providers.** OpenAI-compatible APIs (OpenAI, OpenRouter, vLLM, Ollama) and Anthropic, or your own `LLM` class.
+
+## Install
+
+```bash
+pip install -e ".[all]"        # or pick: .[torch] .[hf] .[openai] .[anthropic]
+export OPENAI_API_KEY=...      # or ANTHROPIC_API_KEY / OPENROUTER_API_KEY
+```
+
+## Quick start
+
+```python
+import torch
+import weightspace as wsp
+
+model = ...  # any torch.nn.Module
+
+
+@wsp.probe
+def accuracy():
+    """Per-class accuracy on a held-out batch."""
+    with torch.no_grad():
+        pred = model(x_val).argmax(-1)
+    return {c: float((pred[y_val == c] == c).float().mean()) for c in range(4)}
+
+
+res = wsp.fix(
+    model,
+    "The classifier never predicts class 3. Find out why and fix it.",
+    llm="openai:gpt-5",  # or "anthropic:claude-sonnet-4-5", "openrouter:..."
+    context="Linear(2->16) -> ReLU -> Linear(16->4); input is a 2D point, output is its quadrant.",
+    probes=[accuracy],
+    forward_budget=3,
+)
+
+print(res)  # answer, confidence, forward passes used, which weights changed
+res.save("runs/fix")  # transcript.jsonl, result.json, patch.npz
+```
+
+The model is edited in place. The other tasks look the same:
+
+```python
+wsp.read(model, "Which game was this policy trained on?", llm=..., context=GRID_AND_ACTIONS)
+wsp.read(model, "What does this network compute?", llm=..., text_mode=True)  # weights in the prompt
+wsp.write(model, "Play Breakout: move the paddle under the ball.", llm=..., context=GAME_RULES)  # zeroes first
+wsp.improve(hf_model, "Stop the reasoning loops.", llm=..., probes=[generate], forward_budget=25)
+```
+
+## Thinking on or off
+
+`thinking` sets how much the editing LLM reasons before it acts. Use `thinking=False` to have it edit the weights with no thinking at all:
+
+```python
+wsp.fix(model, "...", llm="openai:gpt-5.1", thinking=False)  # or "low" / "medium" / "high"; None = provider default
+```
+
+With thinking off, the provider's reasoning is disabled and the LLM is told to go straight to tool calls and edits. How that reaches each provider:
+
+| Backend | off | on |
+|---|---|---|
+| OpenAI | `reasoning_effort="none"` (`OpenAIChat(..., off_effort="minimal")` for gpt-5) | `reasoning_effort=<level>` |
+| OpenRouter | `reasoning.enabled=false` | `reasoning.effort=<level>` |
+| vLLM / SGLang (Qwen3 etc.) | `OpenAIChat(..., thinking_style="chat_template")` → `enable_thinking=false` | `enable_thinking=true` |
+| Anthropic | `thinking.type="disabled"` | extended thinking with a 2k / 8k / 16k token budget |
+
+CLI: `--no-thinking` or `--thinking low|medium|high`. The setting is saved in `result.json`, so you can compare runs with and without thinking.
+
+## Probes
+
+A probe is any function. It runs after the current weights are synced into the model, and whatever it returns is what the LLM sees. Its arguments become the tool's schema.
+
+```python
+@wsp.probe(cost=1)
+def generate(prompts: list, max_new_tokens: int = 256):
+    """Generate answers for up to 8 prompts and report repetition."""
+    ...
+```
+
+Want the LLM to see only attention patterns, not outputs? Write a probe that returns only attention patterns. That's how you set what the LLM can observe.
+
+## Lower level
+
+```python
+ws = wsp.WeightSpace.from_hf("Qwen/Qwen2.5-0.5B-Instruct")  # or from_torch / from_file / from_numpy
+ws.W["model.layers.15.mlp.down_proj.weight"][:, :64] -= ...  # tracked in-place edit
+print(ws.diff())  # what changed vs. the original
+ws.checkpoint("a")
+ws.restore("a")
+ws.revert()
+ws.save_patch("fix.npz")
+other.apply_patch("fix.npz")
+
+s = wsp.Session(
+    ws,
+    llm,
+    mode="improve",
+    probes=[...],
+    forward_budget=50,
+    tools=[my_tool],
+    namespace={"tok": tokenizer},
+    max_steps=80,
+    verbose=True,
+)
+res = s.run("...")
+```
+
+Custom tools: `wsp.tool("name", "description", x={"type": "number"})(fn)`.
+Offline runs and tests: `wsp.ScriptedLLM([...])` replays a fixed script.
+
+## CLI
+
+```bash
+weightspace inspect model.safetensors --describe
+weightspace read model.safetensors "What was this trained to do?" --llm openai:gpt-5 --context @notes.md
+weightspace fix model.safetensors "..." --llm anthropic:claude-sonnet-4-5 --save-weights fixed.safetensors --out runs/1
+```
+
+## Examples
+
+- `examples/fix_quadrants.py`: fix a sabotaged classifier (runs offline with a scripted LLM if you omit `--llm`)
+- `examples/read_which_task.py`: name the boolean function an MLP learned, from its weights in the prompt
+- `examples/hf_reduce_loops.py`: edit a Hugging Face LM to stop repetition loops, with generation and attention probes
+
+## Rules and caveats
+
+The system prompt tells the LLM not to train, fit weights to data, or run the network inside the sandbox; the only way to run it is the budgeted probes. The sandbox never holds the model object, but it is not a security boundary: code runs in your process, and an LLM could still multiply matrices by hand. Check transcripts if the rules matter for your experiment, as the paper's authors did.
+
+## Development
+
+```bash
+pip install -e ".[all,dev]"
+pytest
+ruff check . && ruff format --check .
+```

weightspace-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+weightspace/__init__.py,sha256=mq80-2uZ7EZ6PwREbmNdtdjnaxiwFhm1Gp-QkEoJjyw,1168
+weightspace/adapters.py,sha256=lAv6KGTDso45GtdExduAwq1GkzWlVtwnbjGCC4iO2vk,3742
+weightspace/agent.py,sha256=BMAhUACTnmu3MnhUdVfjrcJrEDUmB9v7dKDHszkB864,18361
+weightspace/cli.py,sha256=RVOdV7j_iWvZKU23BXnGIl5E-Ejf3SnrYvJPAJazpOw,2646
+weightspace/probes.py,sha256=vXGFY_qMEGQDDXnbFPV1TUo3GToScaXZXbuB4hmFV3U,2116
+weightspace/prompts.py,sha256=4Q5RNzZnM0Kg9jajfIMDPC9mjllU1hpxIGuM4FwjpuE,2523
+weightspace/render.py,sha256=5-Dv2I4pIidqZ-DloY6fejTEmpaklIMaFEN4MXvFle8,5419
+weightspace/sandbox.py,sha256=GjBoU1PANP37PSe15UhtgIjK9bigUmGFRyTTNtJpEzU,2452
+weightspace/space.py,sha256=foJz4re5U7LDme155Y-cnr3PasNAIkpfwxJgcA-byPg,10404
+weightspace/tasks.py,sha256=OBoe4plzggy1q4Gtyh0MaEB_N0kzjeWEEp-fAPmjbc8,1932
+weightspace/llm/__init__.py,sha256=iezqhDRZGXJfTiyTj9KFUj2U7BjXXQ9A3Oqiavbafdk,1184
+weightspace/llm/anthropic.py,sha256=a4piOrnNmtYyWBMwt6zZFgA0tT8SWDiBv61mB2FCMBk,5311
+weightspace/llm/base.py,sha256=3wguEIsIbx6e5dzX3yVgM_LJYja7ePBEeZydAxPLH8E,2118
+weightspace/llm/mock.py,sha256=p7qva2VmI1Kz5X6rW-VItMjfGJu47IszYK0f5cHGFRM,1188
+weightspace/llm/openai.py,sha256=NhJXV57430F3Y7EMWr6W5Iodzk9Rg0YjwXYBQtlxedQ,4063
+weightspace-0.1.0.dist-info/METADATA,sha256=_Kcg41CQQYgIkEydrLef5C6wXeyLNrGEXtqNWNLmohI,7712
+weightspace-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+weightspace-0.1.0.dist-info/entry_points.txt,sha256=UrI1f3liF2AwZmh_RRpv3-NAEdb0AqzgZBFzmeG5cNE,53
+weightspace-0.1.0.dist-info/RECORD,,

weightspace-0.1.0.dist-info/WHEEL

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

weightspace-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+weightspace = weightspace.cli:main