interpkit 0.1.0__py3-none-any.whl

interpkit/ops/steer.py

@@ -0,0 +1,118 @@
+"""steer — extract and apply steering vectors."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import torch
+
+from interpkit.ops.patch import _get_module
+
+if TYPE_CHECKING:
+    from interpkit.core.model import Model
+
+
+def run_steer_vector(
+    model: "Model",
+    positive: Any,
+    negative: Any,
+    *,
+    at: str,
+) -> torch.Tensor:
+    """Extract a steering vector: activation(positive) - activation(negative) at module *at*.
+
+    Both inputs are padded to the same length. The vector is the mean
+    difference across the sequence dimension.
+    """
+    from interpkit.ops.activations import run_activations
+
+    pos_act = run_activations(model, positive, at=at, print_stats=False)
+    neg_act = run_activations(model, negative, at=at, print_stats=False)
+
+    # Mean across sequence dim if present
+    if pos_act.dim() >= 3:
+        pos_mean = pos_act[0].mean(dim=0)  # (hidden,)
+        neg_mean = neg_act[0].mean(dim=0)
+    elif pos_act.dim() == 2:
+        pos_mean = pos_act.mean(dim=0)
+        neg_mean = neg_act.mean(dim=0)
+    else:
+        pos_mean = pos_act
+        neg_mean = neg_act
+
+    return pos_mean - neg_mean
+
+
+def run_steer(
+    model: "Model",
+    input_data: Any,
+    *,
+    vector: torch.Tensor,
+    at: str,
+    scale: float = 2.0,
+    save: str | None = None,
+) -> dict[str, Any]:
+    """Run inference with and without a steering vector, compare top predictions."""
+    from interpkit.core.render import render_steer
+
+    model_input = model._prepare(input_data)
+
+    # 1. Original forward
+    original_logits = model._forward(model_input)
+
+    # 2. Steered forward
+    target_mod = _get_module(model._model, at)
+
+    def _steer_hook(_mod: torch.nn.Module, _inp: Any, output: Any) -> Any:
+        if isinstance(output, torch.Tensor):
+            return output + scale * vector.to(output.device)
+        elif isinstance(output, (tuple, list)):
+            steered = output[0] + scale * vector.to(output[0].device)
+            return (steered,) + tuple(output[1:])
+        return output
+
+    handle = target_mod.register_forward_hook(_steer_hook)
+    steered_logits = model._forward(model_input)
+    handle.remove()
+
+    # Extract top tokens
+    original_tokens = _top_tokens(model, original_logits)
+    steered_tokens = _top_tokens(model, steered_logits)
+
+    render_steer(original_tokens, steered_tokens, at, scale)
+
+    if save is not None:
+        from interpkit.core.plot import plot_steer
+
+        plot_steer(original_tokens, steered_tokens, module_name=at, scale=scale, save_path=save)
+
+    return {
+        "original_logits": original_logits,
+        "steered_logits": steered_logits,
+        "original_top": original_tokens,
+        "steered_top": steered_tokens,
+    }
+
+
+def _top_tokens(
+    model: "Model",
+    logits: torch.Tensor,
+    k: int = 10,
+) -> list[tuple[str, float]]:
+    """Extract top-k predicted tokens from logits."""
+    if logits.dim() == 3:
+        last_logits = logits[0, -1, :]
+    elif logits.dim() == 2:
+        last_logits = logits[-1, :]
+    else:
+        last_logits = logits.view(-1)
+
+    probs = torch.softmax(last_logits.float(), dim=-1)
+    top_probs, top_ids = probs.topk(k)
+
+    if model._tokenizer is not None:
+        tokens = [model._tokenizer.decode([tid]) for tid in top_ids.tolist()]
+    else:
+        tokens = [str(tid) for tid in top_ids.tolist()]
+
+    return list(zip(tokens, top_probs.tolist()))

interpkit/ops/trace.py

@@ -0,0 +1,182 @@
+"""trace — two-phase causal tracing across all modules, ranked by causal effect."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any
+
+import torch
+from rich.console import Console
+from rich.progress import Progress
+
+from interpkit.ops.patch import _compute_effect, _get_module
+
+if TYPE_CHECKING:
+    from interpkit.core.model import Model
+
+console = Console()
+
+
+def run_trace(
+    model: "Model",
+    clean: Any,
+    corrupted: Any,
+    *,
+    top_k: int | None = 20,
+    save: str | None = None,
+    html: str | None = None,
+) -> list[dict[str, Any]]:
+    """Two-phase causal tracing.
+
+    Phase 1 (fast proxy): run clean and corrupted forward passes, capture activation
+    norms at every module, rank by norm delta.
+
+    Phase 2 (expensive): for the top-K modules by proxy score, run full
+    patch-and-measure to get true causal effect.
+    """
+    from interpkit.core.render import render_trace
+
+    clean_input, corrupted_input = model._prepare_pair(clean, corrupted)
+
+    # Filter to leaf modules with parameters (skip containers)
+    candidates = [
+        m for m in model.arch_info.modules
+        if m.param_count > 0
+    ]
+
+    total_modules = len(candidates)
+
+    if top_k == 0:
+        top_k = None
+
+    # ----------------------------------------------------------------
+    # Phase 1: fast proxy — activation norm delta
+    # ----------------------------------------------------------------
+    clean_norms: dict[str, float] = {}
+    corrupted_norms: dict[str, float] = {}
+
+    def _make_norm_hook(store: dict[str, float], name: str):
+        def hook_fn(_mod: torch.nn.Module, _inp: Any, output: Any) -> None:
+            t = output if isinstance(output, torch.Tensor) else (
+                output[0] if isinstance(output, (tuple, list)) and isinstance(output[0], torch.Tensor) else None
+            )
+            if t is not None:
+                store[name] = t.detach().float().norm().item()
+        return hook_fn
+
+    # Clean pass
+    hooks = []
+    for m in candidates:
+        mod = _get_module(model._model, m.name)
+        hooks.append(mod.register_forward_hook(_make_norm_hook(clean_norms, m.name)))
+    with torch.no_grad():
+        clean_logits = model._forward(clean_input)
+    for h in hooks:
+        h.remove()
+
+    # Corrupted pass
+    hooks = []
+    for m in candidates:
+        mod = _get_module(model._model, m.name)
+        hooks.append(mod.register_forward_hook(_make_norm_hook(corrupted_norms, m.name)))
+    with torch.no_grad():
+        corrupted_logits = model._forward(corrupted_input)
+    for h in hooks:
+        h.remove()
+
+    # Rank by proxy: absolute norm difference
+    proxy_scores: list[tuple[str, float]] = []
+    for m in candidates:
+        cn = clean_norms.get(m.name, 0.0)
+        crn = corrupted_norms.get(m.name, 0.0)
+        proxy_scores.append((m.name, abs(cn - crn)))
+
+    proxy_scores.sort(key=lambda x: x[1], reverse=True)
+
+    # Select top-K for expensive phase
+    if top_k is not None and top_k < total_modules:
+        selected_names = {name for name, _ in proxy_scores[:top_k]}
+        console.print(
+            f"\n  Scanning top {top_k} of {total_modules} modules by proxy score."
+        )
+    else:
+        selected_names = {name for name, _ in proxy_scores}
+
+    # ----------------------------------------------------------------
+    # Phase 2: full causal patching on selected modules
+    # ----------------------------------------------------------------
+
+    # Cache all clean activations in one pass
+    clean_cache: dict[str, torch.Tensor] = {}
+
+    def _make_cache_hook(name: str):
+        def hook_fn(_mod: torch.nn.Module, _inp: Any, output: Any) -> None:
+            t = output if isinstance(output, torch.Tensor) else (
+                output[0] if isinstance(output, (tuple, list)) and isinstance(output[0], torch.Tensor) else None
+            )
+            if t is not None:
+                clean_cache[name] = t.detach().clone()
+        return hook_fn
+
+    hooks = []
+    for m in candidates:
+        if m.name in selected_names:
+            mod = _get_module(model._model, m.name)
+            hooks.append(mod.register_forward_hook(_make_cache_hook(m.name)))
+    with torch.no_grad():
+        clean_logits = model._forward(clean_input)
+    for h in hooks:
+        h.remove()
+
+    # Patch each selected module one at a time
+    results: list[dict[str, Any]] = []
+    module_role_map = {m.name: m.role for m in candidates}
+
+    with Progress(console=console, transient=True) as progress:
+        task = progress.add_task("Causal tracing", total=len(selected_names))
+        for name in selected_names:
+            if name not in clean_cache:
+                progress.advance(task)
+                continue
+
+            target_mod = _get_module(model._model, name)
+
+            def _make_patch_hook(cached: torch.Tensor):
+                def hook_fn(_mod: torch.nn.Module, _inp: Any, output: Any) -> Any:
+                    if isinstance(output, torch.Tensor):
+                        return cached
+                    elif isinstance(output, (tuple, list)):
+                        return (cached,) + tuple(output[1:])
+                    return output
+                return hook_fn
+
+            handle = target_mod.register_forward_hook(_make_patch_hook(clean_cache[name]))
+            with torch.no_grad():
+                patched_logits = model._forward(corrupted_input)
+            handle.remove()
+
+            effect = _compute_effect(clean_logits, corrupted_logits, patched_logits)
+            results.append({
+                "module": name,
+                "role": module_role_map.get(name),
+                "effect": effect,
+            })
+            progress.advance(task)
+
+    results.sort(key=lambda x: x["effect"], reverse=True)
+
+    model_name = model.arch_info.arch_family or "model"
+    render_trace(results, model_name, total_modules, top_k)
+
+    if save is not None:
+        from interpkit.core.plot import plot_trace
+
+        plot_trace(results, model_name=model_name, save_path=save)
+
+    if html is not None:
+        from interpkit.core.html import html_trace as gen_html_trace
+        from interpkit.core.html import save_html
+
+        save_html(gen_html_trace(results), html)
+
+    return results

interpkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.4
+Name: interpkit
+Version: 0.1.0
+Summary: Mech interp for any HuggingFace model.
+Author: Davide Zani
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/davidezani/InterpKit
+Project-URL: Repository, https://github.com/davidezani/InterpKit
+Project-URL: Issues, https://github.com/davidezani/InterpKit/issues
+Keywords: mechanistic-interpretability,pytorch,transformers,mech-interp,interpretability
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.1
+Requires-Dist: transformers>=4.36
+Requires-Dist: nnsight>=0.3
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.9
+Requires-Dist: Pillow>=10.0
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: huggingface-hub>=0.20
+Provides-Extra: probe
+Requires-Dist: scikit-learn>=1.3; extra == "probe"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-timeout>=2.2; extra == "dev"
+Requires-Dist: scikit-learn>=1.3; extra == "dev"
+Dynamic: license-file
+
+# InterpKit
+
+> Mech interp for any HuggingFace model.
+
+[![PyPI version](https://img.shields.io/pypi/v/interpkit.svg)](https://pypi.org/project/interpkit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+---
+
+## The Problem
+
+TransformerLens is excellent — but only works on GPT-style decoder-only transformers. The moment you step outside that (Mamba, SSMs, ViT, CNNs, BERT, T5, MoE models), there is no equivalent tool. You write hook code from scratch every time.
+
+InterpKit fills this gap: the same standard mech interp operations, on any HuggingFace model, with no annotation required.
+
+---
+
+## Install
+
+```bash
+pip install interpkit
+
+# For linear probe support:
+pip install interpkit[probe]
+```
+
+Or install from source for development:
+
+```bash
+git clone https://github.com/davidezani/InterpKit.git
+cd InterpKit
+pip install -e ".[dev]"
+```
+
+---
+
+## Quickstart
+
+```python
+import interpkit
+
+model = interpkit.load("gpt2")
+
+model.inspect()                    # module tree with roles, params, shapes
+model.trace("...Paris...", "...Rome...", top_k=20)   # causal tracing
+model.patch("...Paris...", "...Rome...", at="transformer.h.8.mlp")
+model.lens("The capital of France is")               # logit lens
+model.attribute("The capital of France is")          # gradient saliency
+```
+
+Works the same on any HF architecture:
+
+```python
+model = interpkit.load("state-spaces/mamba-370m")
+model = interpkit.load("google/vit-base-patch16-224")
+model = interpkit.load("bert-base-uncased")
+```
+
+---
+
+## Operations
+
+| Operation | What it does | Works on |
+|-----------|-------------|----------|
+| `inspect` | Module tree with types, param counts, shapes | Any model |
+| `patch` | Activation patching at a named module | Any model |
+| `trace` | Causal tracing across modules, ranked by effect | Any model |
+| `attribute` | Gradient saliency over inputs | Any model |
+| `lens` | Logit lens — project activations to vocabulary | LMs (auto-detected) |
+| `activations` | Extract raw activation tensors at any module | Any model |
+| `ablate` | Zero/mean ablate a component and measure effect | Any model |
+| `attention` | Visualize attention patterns per layer/head | Transformers |
+| `steer` | Extract and apply steering vectors | Any model |
+| `probe` | Linear probe on activations | Any model |
+| `diff` | Compare activations between two models | Any model |
+| `features` | SAE feature decomposition | Any model |
+
+---
+
+## Activations, Ablation, Attention
+
+```python
+# Extract raw activations
+act = model.activations("The capital of France is", at="transformer.h.8.mlp")
+acts = model.activations("...", at=["transformer.h.0", "transformer.h.8.mlp"])
+
+# Ablation — zero or mean
+result = model.ablate("The capital of France is", at="transformer.h.8.mlp")
+result = model.ablate("...", at="transformer.h.8.mlp", method="mean")
+
+# Attention patterns
+model.attention("The capital of France is")                   # all layers
+model.attention("The capital of France is", layer=8, head=3)  # single head
+```
+
+## Steering
+
+```python
+# 1. Extract a steering vector
+vector = model.steer_vector("Love", "Hate", at="transformer.h.8")
+
+# 2. Apply during inference — side-by-side comparison
+model.steer("The weather today is", vector=vector, at="transformer.h.8", scale=2.0)
+```
+
+## Linear Probe
+
+```python
+result = model.probe(
+    texts=["The cat sat", "The dog ran", "A bird flew", "A fish swam"],
+    labels=[0, 0, 1, 1],
+    at="transformer.h.8",
+)
+print(result["accuracy"])
+```
+
+## Model Diff
+
+```python
+base = interpkit.load("gpt2")
+finetuned = interpkit.load("my-finetuned-gpt2")
+interpkit.diff(base, finetuned, "The capital of France is")
+```
+
+## SAE Features
+
+Decompose activations into interpretable features using pre-trained Sparse Autoencoders from HuggingFace:
+
+```python
+model.features(
+    "The capital of France is",
+    at="transformer.h.8",
+    sae="jbloom/GPT2-Small-SAEs-Reformatted",
+)
+```
+
+No SAELens dependency — weights are loaded directly via `safetensors`.
+
+## Activation Cache
+
+Avoid redundant forward passes when exploring the same input with multiple operations:
+
+```python
+model.cache("The capital of France is")  # one forward pass, cache all layers
+model.activations("The capital of France is", at="transformer.h.8.mlp")  # instant
+model.activations("The capital of France is", at="transformer.h.0.mlp")  # instant
+
+model.clear_cache()  # free memory
+```
+
+---
+
+## Visualizations
+
+Pass `save="path.png"` to export a static matplotlib figure, or `html="path.html"` for an interactive visualization:
+
+```python
+model.attention("hello world", layer=0, head=0, save="attention.png")
+model.trace("...Paris...", "...Rome...", save="trace.png")
+model.lens("The capital of France is", save="lens.png")
+model.steer("The weather is", vector=vector, at="transformer.h.8", save="steer.png")
+model.attribute("The capital of France is", save="attribution.png")
+interpkit.diff(base, finetuned, "...", save="diff.png")
+
+# Interactive HTML — self-contained files with hover tooltips, filters, and sliders
+model.attention("hello world", html="attention.html")
+model.trace("...Paris...", "...Rome...", html="trace.html")
+model.attribute("The capital of France is", html="attribution.html")
+```
+
+---
+
+## CLI
+
+```bash
+interpkit inspect gpt2
+interpkit trace gpt2 --clean "...Paris..." --corrupted "...Rome..." --top-k 20
+interpkit lens gpt2 "The capital of France is"
+interpkit attention gpt2 "The capital of France is" --layer 8 --save attention.png
+interpkit steer gpt2 "The weather is" --positive Love --negative Hate --at transformer.h.8
+interpkit ablate gpt2 "The capital of France is" --at transformer.h.8.mlp
+interpkit diff gpt2 my-finetuned-gpt2 "The capital of France is" --save diff.png
+interpkit features gpt2 "The capital of France is" --at transformer.h.8 --sae jbloom/GPT2-Small-SAEs-Reformatted
+
+# Interactive HTML output
+interpkit attention gpt2 "hello world" --html attention.html
+interpkit trace gpt2 --clean "...Paris..." --corrupted "...Rome..." --html trace.html
+interpkit attribute gpt2 "The capital of France is" --html attribution.html
+
+# Vision models — auto-preprocessed
+interpkit attribute microsoft/resnet-50 cat.jpg --target 281
+```
+
+Run `interpkit` with no arguments for a full command reference.
+
+---
+
+## TransformerLens interop
+
+Already using TransformerLens? Pass your `HookedTransformer` directly into InterpKit — it auto-detects the model and extracts the tokenizer:
+
+```python
+from transformer_lens import HookedTransformer
+import interpkit
+
+tl_model = HookedTransformer.from_pretrained("gpt2")
+model = interpkit.load(tl_model)
+
+# All InterpKit operations work on TL models
+model.trace("The Eiffel Tower is in Paris", "The Eiffel Tower is in Rome", top_k=20)
+model.attention("The capital of France is", save="attention.png")
+model.steer("The weather is", vector=vector, at="blocks.8", scale=2.0)
+```
+
+Translate between native and TL hook point names:
+
+```python
+interpkit.to_tl_name("transformer.h.8.mlp")       # -> "blocks.8.mlp"
+interpkit.to_native_name("blocks.8.attn", model.arch_info)  # -> "transformer.h.8.attn"
+interpkit.list_tl_hooks(tl_model)                  # -> ["blocks.0.hook_resid_pre", ...]
+```
+
+---
+
+## Local models
+
+```python
+import torch.nn as nn
+import interpkit
+
+my_model = MyCustomModel()
+interpkit.register(my_model, layers=["blocks.0", "blocks.1"], output_head="head")
+model = interpkit.load(my_model, tokenizer=my_tokenizer)
+model.trace(input_a, input_b, top_k=10)
+```
+
+---
+
+## Examples
+
+See the [`examples/`](examples/) directory for Jupyter notebooks:
+
+| Notebook | Topics |
+|----------|--------|
+| `01_quickstart` | Inspect, trace, lens, attribution, patching, ablation |
+| `02_attention_patterns` | Per-head heatmaps, layer filtering, HTML export |
+| `03_steering_vectors` | Extract and apply steering vectors at different layers/scales |
+| `04_sae_features` | Sparse Autoencoder feature decomposition |
+| `05_caching_and_probing` | Activation cache, linear probes across layers |
+| `06_model_comparison` | Diff two models, side-by-side tracing and logit lens |
+| `07_vision_models` | ResNet/ViT attribution, ablation, activations |
+
+---
+
+## License
+
+MIT

interpkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+interpkit/__init__.py,sha256=cTks5G9HHVi0VFvqKnTrI5lhI-6b6ECuLtk81R20uhU,542
+interpkit/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+interpkit/cli/main.py,sha256=hsAA33eodAsi0wAawbAyWRRGiiQCseCOJOIhje-KFng,17428
+interpkit/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+interpkit/core/discovery.py,sha256=hs9nFHSO7Tr7nkAPZSGYi8CEsZ0DLgmPBDl_cJLudVs,7285
+interpkit/core/html.py,sha256=VnIszOvjMKl3erCIiE4pIsQSPg6_qOvlXgtRH1IniUQ,12317
+interpkit/core/inputs.py,sha256=gsF5ljcCV18s3caglwiTz4TSQ6w6kphGrAYQkDgSTV4,4137
+interpkit/core/model.py,sha256=JBZToZ_pd71zES9pl8N3hCNm-KK5ALX0Irys20loUn0,18308
+interpkit/core/plot.py,sha256=B9V4_R-2zWPIFwaL96uqBbrSz3OCC_vKeZcm2wnAyQ0,12051
+interpkit/core/registry.py,sha256=dUJPiVMomk5QSjarKrw-yvNyteuukkjga823yzNN_YM,2162
+interpkit/core/render.py,sha256=REAGSelRybnf-7HYCb7-YCXUKTd5QOmxHv3FKtehnWY,15914
+interpkit/core/tl_compat.py,sha256=44ffZ7__JrgKf4e5UmaQ3fZLIAqjmw1VhjqqA_rD-AQ,6416
+interpkit/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+interpkit/ops/ablate.py,sha256=CYgZzuIeP8iS2gK2ax5zZi9jDbG6dtldsMcb7S8B6oo,2828
+interpkit/ops/activations.py,sha256=B4OP3cX23eUSP4oYWle7pxb6AzxVh3-dwBDFWtyvVag,1965
+interpkit/ops/attention.py,sha256=qZxZvMoHmcpr47TbJInTdqrFZSk2PTlgyvdXN4T5bQs,7958
+interpkit/ops/attribute.py,sha256=utqAijEhGpYKpMjufuNgrF2ouLdkwlXGkjAX8_Qubp8,7027
+interpkit/ops/diff.py,sha256=SuC6qEgBgoeq5aM51onA7FHTrYMFHJdDtoULVcgotbU,2516
+interpkit/ops/inspect.py,sha256=VUOamp5ePIIlUHZVwhBLmkr78hCv-aOmCwDyDyGn3KQ,356
+interpkit/ops/lens.py,sha256=f3m8_pxXslntUAAPkftX7xVqlYqweIB2cCInoBs0p64,4782
+interpkit/ops/patch.py,sha256=eiW_2NM73TErsvA63IrxOKhcB5SohF0q-jE0Y6Uckek,3730
+interpkit/ops/probe.py,sha256=A4dTKxrUtilchXK-wd831Ry1bFAbtCXyZNIRh-INPWc,3852
+interpkit/ops/sae.py,sha256=mSIfvzxODvEnHkB1X98hmxP9dCgbrLFeYF6duKEYQyc,6275
+interpkit/ops/steer.py,sha256=1zyG_OHl-5pT9mziklPJsV3Z7nsiIRP9TubuKyv1wcM,3407
+interpkit/ops/trace.py,sha256=kcLhYCyshbmL4B9BcLP4RVedpsHvf0TQAA9KRBMNKQM,6249
+interpkit-0.1.0.dist-info/licenses/LICENSE,sha256=_kFMCpDgee4UrUPtrYy3fB-h9SwKJ_saecsNbQTNXIY,1068
+interpkit-0.1.0.dist-info/METADATA,sha256=DI_IG1xxM8olIv5wi9HN1YbBk81K-Gw8rmJH7MNo1Bg,9714
+interpkit-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+interpkit-0.1.0.dist-info/entry_points.txt,sha256=80W12z7dMTFc6DAU_vVU0MQ0xfhYSSFIlwzl6sIdBVg,53
+interpkit-0.1.0.dist-info/top_level.txt,sha256=41VDlyHKdt6ePGIEKnazC4wsDpj1udXamgEP5haogk4,10
+interpkit-0.1.0.dist-info/RECORD,,

interpkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

interpkit-0.1.0.dist-info/entry_points.txt

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

interpkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Davide Zani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

interpkit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+interpkit