model-unfolder 0.2.0__py3-none-any.whl

model_unfolder/renderers/html/views.py

@@ -0,0 +1,461 @@
+"""Top-level SVG views for architecture and layer maps."""
+from __future__ import annotations
+
+from ...labels import kind_short, mask_short
+from .metadata import _block_label, _indices_summary, _signature
+from .svg import (
+    _branch_dot,
+    _defs,
+    _elbow_hv,
+    _input_tap,
+    _ids,
+    _plus_block,
+    _rect_block,
+    _region_rect,
+    _residual_loop_right,
+    _svg,
+    _svg_tag,
+    _svg_text,
+    _v_line,
+)
+from .theme import C, FONT_BODY, FONT_HEAD, FONT_MONO, GAP
+
+
+# --- Layout vocabulary for the data-driven architecture view ----------------
+# Each ``kind`` declares its glyph (rect / circle), nominal size, and font.
+# A new architectural feature gets rendered by adding a kind here and tagging
+# the relevant blocks in the adapter — no edits to the layout engine itself.
+_KIND_LAYOUT = {
+    "norm":         {"shape": "rect",   "w": 160, "h": 36, "font": 16},
+    "linear":       {"shape": "rect",   "w": 200, "h": 38, "font": 15},
+    "activation":   {"shape": "rect",   "w": 150, "h": 36, "font": 15},
+    "attention":    {"shape": "rect",   "w": 230, "h": 60, "font": 17},
+    "ffn":          {"shape": "rect",   "w": 160, "h": 44, "font": 17},
+    "ple":          {"shape": "rect",   "w": 160, "h": 44, "font": 17},
+    "residual_add": {"shape": "circle", "w": 28,  "h": 28, "sym": "+"},
+    "gate_mul":     {"shape": "circle", "w": 28,  "h": 28, "sym": "×"},
+}
+_BLOCK_GAP = 32  # vertical gap between consecutive layer-body blocks
+# Larger than the arrow padding (`GAP` ×2) so the chain arrow has a visible
+# stem between blocks rather than collapsing to just an arrowhead.
+
+
+def _build_architecture_view(ir: dict, info: dict, mount_id: str) -> str:
+    """Data-driven decoder architecture view.
+
+    The layer body comes from ``info['dominant']['spec']['blocks']`` — an
+    ordered list of typed blocks emitted by the adapter.  Each block's
+    ``kind`` selects a glyph in :data:`_KIND_LAYOUT`; ``residual_from`` adds
+    a residual loop when the bypass is not already represented by the central
+    chain; side-lane blocks render as parallel rails to the left or right of
+    the inner region.
+
+    The view grows from the block list, so side-path models get extra vertical
+    space while compact decoder-only models keep the same vocabulary.
+    """
+    spec = info["dominant"]["spec"]
+    layer_blocks = list(spec.get("blocks") or [])
+
+    # Side blocks live OFF the central column.  They share a row with the block
+    # they feed but get their own offset x-position and explicit connections.
+    chain_blocks = [b for b in layer_blocks if not b.get("lane")]
+    side_blocks = [b for b in layer_blocks if b.get("lane")]
+
+    cx = 360
+    inner_x, inner_w = 110, 500
+
+    # --- 1. Compute heights from the chain block list ---
+    inner_padding = 60
+    stack_h = _layer_stack_height(chain_blocks)
+    inner_h = max(490, stack_h + 2 * inner_padding)
+
+    inner_y = 200
+    h = inner_y + inner_h + 232  # 232 = embed + tok_text + bottom padding
+    w = 720
+
+    arrow_id, shadow_id = _ids(mount_id, "arch")
+    parts = [_defs(arrow_id, shadow_id)]
+    parts.append(_region_rect(40, 26, w - 80, h - 52, C["bg_outer"]))
+    parts.append(_region_rect(inner_x, inner_y, inner_w, inner_h, C["bg_inner"]))
+
+    # --- 2. Model-level scaffold (positions tracked by total height h) ---
+    tok_text = _rect_block(parts, info, shadow_id, "tok_text",
+                           cx - 110, h - 100, 220, 44,
+                           _block_label(info, "tok_text", "Tokenized text"), font_size=17)
+    embed = _rect_block(parts, info, shadow_id, "embed",
+                        cx - 130, h - 168, 260, 44,
+                        _block_label(info, "embed", "Token Embedding layer"), font_size=17)
+    final_rms = _rect_block(parts, info, shadow_id, "final_rms",
+                            cx - 90, 140, 180, 36,
+                            _block_label(info, "final_rms", "Final RMSNorm"), font_size=16)
+    lm_head = _rect_block(parts, info, shadow_id, "lm_head",
+                          cx - 130, 70, 260, 44,
+                          _block_label(info, "lm_head", "Linear output layer"), font_size=17)
+
+    # --- 3. Layer body (data-driven, stacked bottom-up) ---
+    block_pos: dict[str, dict] = {}
+    free = inner_h - stack_h
+    y_cursor = inner_y + inner_h - free / 2
+    for block in chain_blocks:
+        layout = _KIND_LAYOUT.get(block["kind"]) or _KIND_LAYOUT["norm"]
+        block_h = layout["h"]
+        top = y_cursor - block_h
+        if layout["shape"] == "rect":
+            geom = _rect_block(
+                parts, info, shadow_id, block["id"],
+                cx - layout["w"] / 2, top, layout["w"], block_h,
+                _block_label(info, block["id"], block.get("label")),
+                font_size=layout["font"],
+            )
+        else:
+            geom = _plus_block(
+                parts, info, shadow_id, block["id"],
+                cx, top + block_h / 2, sym=layout.get("sym", "+"),
+            )
+        block_pos[block["id"]] = geom
+        y_cursor = top - _BLOCK_GAP
+
+    # --- 4. Linear chain arrows ---
+    chain = [tok_text, embed] + [block_pos[b["id"]] for b in chain_blocks] + [final_rms, lm_head]
+    for src, dst in zip(chain, chain[1:]):
+        parts.append(_v_line(src, dst, arrow_id))
+
+    # Output arrow above lm_head.
+    parts.append(_svg_tag("line", {
+        "x1": cx, "y1": lm_head["top"], "x2": cx, "y2": lm_head["top"] - 32,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+
+    # --- 5. Residual loops (declared via residual_from) ---
+    chain_ids = [b["id"] for b in chain_blocks]
+    chain_prev = {block_id: chain_ids[i - 1] for i, block_id in enumerate(chain_ids[1:], start=1)}
+    branch_taps: set[tuple[float, float]] = set()
+    lane = inner_x + inner_w - 28
+    for block in layer_blocks:
+        src_id = block.get("residual_from")
+        if src_id and src_id in block_pos and block["id"] in block_pos:
+            if chain_prev.get(block["id"]) == src_id:
+                continue
+            src_geom = block_pos[src_id]
+            dst_geom = block_pos[block["id"]]
+            parts.append(_residual_loop_right(src_geom, dst_geom, lane, arrow_id))
+            # Junction dot at the tap point on the input-arrow stem so the
+            # bypass visually originates from the arrow, not from the block.
+            _mark_branch_tap(parts, branch_taps, _input_tap(src_geom))
+
+    # --- 6. Side blocks — placed off the central column ---
+    for block in side_blocks:
+        _draw_side_block(
+            parts, info, shadow_id,
+            block, block_pos,
+            inner_x, inner_w, arrow_id, branch_taps,
+        )
+
+    # --- 7. × N badge over the inner region ---
+    parts.append(_svg_tag("rect", {
+        "x": inner_x + inner_w - 78, "y": inner_y + 12,
+        "width": 66, "height": 26, "rx": 13, "ry": 13,
+        "fill": "rgba(255,255,255,0.65)", "stroke": C["border"], "stroke-width": 0.5,
+    }))
+    parts.append(_svg_text(
+        inner_x + inner_w - 45, inner_y + 25,
+        f"x {len(ir.get('layers', []))}",
+        {"text-anchor": "middle", "dominant-baseline": "central",
+         "fill": C["text"], "font-family": FONT_HEAD, "font-size": 20},
+    ))
+
+    return _svg(w, h, f"{ir.get('name', 'model')} architecture", parts)
+
+
+def _layer_stack_height(layer_blocks: list[dict]) -> int:
+    if not layer_blocks:
+        return 0
+    total = sum(_KIND_LAYOUT.get(b["kind"], _KIND_LAYOUT["norm"])["h"] for b in layer_blocks)
+    total += _BLOCK_GAP * (len(layer_blocks) - 1)
+    return total
+
+
+def _draw_side_block(
+    parts: list[str],
+    info: dict,
+    shadow_id: str,
+    block: dict,
+    block_pos: dict,
+    inner_x: float,
+    inner_w: float,
+    arrow_id: str,
+    branch_taps: set[tuple[float, float]],
+) -> None:
+    """Render a block that lives OFF the central chain.
+
+    The block is drawn at the y-row of whatever it ``feeds``, offset to the
+    declared ``lane`` (left/right).  Its input is a long arrow tapping the
+    chain at the bottom of the ``tap_from`` block; its output is a short
+    horizontal arrow into the ``feeds`` target.
+    """
+    layout = _KIND_LAYOUT.get(block["kind"]) or _KIND_LAYOUT["norm"]
+    block_w = layout["w"]
+    block_h = layout["h"]
+    lane = block.get("lane", "left")
+    feeds_id = block.get("feeds")
+    tap_id = block.get("tap_from")
+
+    feeds_geom = block_pos.get(feeds_id) if feeds_id else None
+    tap_geom = block_pos.get(tap_id) if tap_id else None
+    if not feeds_geom or not tap_geom:
+        return  # mis-declared; nothing to anchor to
+
+    # Side block sits at the same y as the block it feeds, shifted left/right.
+    cy = feeds_geom["cy"]
+    if lane == "left":
+        block_x = inner_x + 30
+    else:
+        block_x = inner_x + inner_w - 30 - block_w
+    top = cy - block_h / 2
+
+    geom = _rect_block(
+        parts, info, shadow_id, block["id"],
+        block_x, top, block_w, block_h,
+        _block_label(info, block["id"], block.get("label")),
+        font_size=layout["font"],
+    )
+    block_pos[block["id"]] = geom
+
+    # --- Input: long arrow up the side, tapping the chain at tap_from's input
+    #     stem (so the visual reads "the same x flowing into the layer also
+    #     feeds this side block").  Routed as a rounded L-bend.
+    rail_x = geom["cx"]
+    tap_x, tap_y = _input_tap(tap_geom)
+    parts.append(_elbow_hv(tap_x, tap_y, rail_x, geom["bottom"] + GAP, arrow_id))
+    _mark_branch_tap(parts, branch_taps, (tap_x, tap_y))
+
+    # --- Output: short horizontal arrow into feeds target.
+    if lane == "left":
+        x1 = geom["right"]
+        x2 = feeds_geom["left"] - GAP
+    else:
+        x1 = geom["left"]
+        x2 = feeds_geom["right"] + GAP
+    parts.append(_svg_tag("line", {
+        "x1": x1, "y1": cy, "x2": x2, "y2": cy,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+
+
+def _mark_branch_tap(
+    parts: list[str],
+    branch_taps: set[tuple[float, float]],
+    tap: tuple[float, float],
+) -> None:
+    key = (round(tap[0], 3), round(tap[1], 3))
+    if key in branch_taps:
+        return
+    branch_taps.add(key)
+    parts.append(_branch_dot(*tap))
+
+
+def _build_layer_map(ir: dict, info: dict, mount_id: str) -> str:
+    w = 720
+    layers = ir.get("layers", [])
+    kv_shared_indices = [
+        i for i, layer in enumerate(layers)
+        if (layer.get("attention") or {}).get("kv_source_layer") is not None
+    ]
+    has_kv_share = bool(kv_shared_indices)
+    n_legend_rows = len(info["groups"]) + (1 if has_kv_share else 0)
+    # Reserve extra room for the optional "KV CACHE" sub-strip and its annotation.
+    extra = 56 if has_kv_share else 0
+    h = max(240, 160 + extra + 22 * n_legend_rows)
+    arrow_id, shadow_id = _ids(mount_id, "map")
+    parts = [_defs(arrow_id, shadow_id)]
+    parts.append(_hatch_pattern(mount_id))
+    parts.append(_region_rect(40, 30, w - 80, h - 60, C["bg_card"], stroke=C["border"], stroke_width=0.5))
+
+    # Green-family palette so the layer map shares the diagram's theme.
+    # Ordered dark → light so consecutive groups read like a gradient step.
+    palette = ["#0F6E56", "#1F9E78", "#5BB89A", "#0A4F3F", "#7FCFB4", "#0E5C48", "#A0E3CD"]
+    sig_to_color = {group["sig"]: palette[i % len(palette)] for i, group in enumerate(info["groups"])}
+
+    strip_x, strip_y, strip_w, strip_h = 80, 90, w - 160, 36
+    n = len(layers)
+    col_w = strip_w / max(n, 1)
+
+    layer_sigs = info.get("layer_sigs") or [_signature(layer) for layer in layers]
+    for i, sig in enumerate(layer_sigs):
+        parts.append(
+            _svg_tag(
+                "rect",
+                {
+                    "x": strip_x + i * col_w,
+                    "y": strip_y,
+                    "width": max(col_w - 0.5, 1),
+                    "height": strip_h,
+                    "fill": sig_to_color.get(sig, palette[0]),
+                    "opacity": 0.95,
+                },
+            )
+        )
+
+    # KV-share overlay — diagonal hatch on layers that don't compute their own K/V.
+    for i in kv_shared_indices:
+        parts.append(
+            _svg_tag(
+                "rect",
+                {
+                    "x": strip_x + i * col_w,
+                    "y": strip_y,
+                    "width": max(col_w - 0.5, 1),
+                    "height": strip_h,
+                    "fill": f"url(#uf-{mount_id}-hatch)",
+                    "pointer-events": "none",
+                },
+            )
+        )
+
+    parts.append(
+        _svg_tag(
+            "rect",
+            {
+                "x": strip_x,
+                "y": strip_y,
+                "width": strip_w,
+                "height": strip_h,
+                "fill": "none",
+                "stroke": C["text"],
+                "stroke-width": 0.4,
+                "rx": 4,
+                "ry": 4,
+            },
+        )
+    )
+
+    if n:
+        for idx in (0, n - 1):
+            x = strip_x + (idx + 0.5) * col_w
+            parts.append(
+                _svg_text(
+                    x,
+                    strip_y + strip_h + 16,
+                    f"L{idx}",
+                    {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 10},
+                )
+            )
+
+    type_word = "type" if len(info["groups"]) == 1 else "types"
+    parts.append(
+        _svg_text(
+            strip_x,
+            70,
+            f"{n} layers - {len(info['groups'])} {type_word}",
+            {"fill": C["text"], "font-family": FONT_BODY, "font-size": 12, "font-weight": 600},
+        )
+    )
+
+    legend_y = strip_y + strip_h + 44
+
+    if has_kv_share:
+        first = kv_shared_indices[0]
+        last = kv_shared_indices[-1]
+        # Bracket above the strip marking where KV reuse kicks in.
+        bracket_y = strip_y - 8
+        x_start = strip_x + first * col_w
+        x_end = strip_x + (last + 1) * col_w - 0.5
+        parts.append(
+            _svg_tag(
+                "path",
+                {
+                    "d": f"M {x_start} {bracket_y - 6} L {x_start} {bracket_y} L {x_end} {bracket_y} L {x_end} {bracket_y - 6}",
+                    "fill": "none",
+                    "stroke": C["muted"],
+                    "stroke-width": 1.0,
+                    "stroke-linecap": "round",
+                },
+            )
+        )
+        # Sources of the K/V tensors — collected from cross-layer edges.
+        edges = ir.get("cross_layer_edges") or []
+        kv_sources = sorted({e.get("from_layer") for e in edges if e.get("kind") == "kv_share"})
+        src_summary = (
+            f"L{kv_sources[0]}–L{kv_sources[-1]}" if len(kv_sources) > 1
+            else (f"L{kv_sources[0]}" if kv_sources else "earlier layer")
+        )
+        share_label = (
+            f"K/V reused: L{first}–L{last} ({len(kv_shared_indices)} layers)  ←  {src_summary}"
+        )
+        parts.append(
+            _svg_text(
+                (x_start + x_end) / 2,
+                bracket_y - 12,
+                share_label,
+                {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 10},
+            )
+        )
+        legend_y += 8
+
+    lx, ly = strip_x, legend_y
+    for group in info["groups"]:
+        spec = group["spec"]
+        ffn_kind = "MoE" if spec["ffn"].get("kind") == "moe" else "Dense"
+        attn = spec.get("attention", {})
+        label = (
+            f"{kind_short(attn)} + {ffn_kind} ({mask_short(attn)})"
+            f"  ·  {_indices_summary(group, info)}"
+        )
+        color = sig_to_color[group["sig"]]
+        parts.append(_svg_tag("rect", {"x": lx, "y": ly - 9, "width": 12, "height": 12, "fill": color, "rx": 2}))
+        parts.append(
+            _svg_text(
+                lx + 18,
+                ly,
+                label,
+                {"dominant-baseline": "central", "fill": C["text"], "font-family": FONT_BODY, "font-size": 12},
+            )
+        )
+        ly += 20
+
+    if has_kv_share:
+        # Hatched chip in the legend.
+        parts.append(
+            _svg_tag(
+                "rect",
+                {"x": lx, "y": ly - 9, "width": 12, "height": 12, "fill": palette[0], "rx": 2},
+            )
+        )
+        parts.append(
+            _svg_tag(
+                "rect",
+                {
+                    "x": lx,
+                    "y": ly - 9,
+                    "width": 12,
+                    "height": 12,
+                    "fill": f"url(#uf-{mount_id}-hatch)",
+                    "rx": 2,
+                },
+            )
+        )
+        parts.append(
+            _svg_text(
+                lx + 18,
+                ly,
+                f"K/V reused (no own K/V projections)  ·  {len(kv_shared_indices)} layers",
+                {"dominant-baseline": "central", "fill": C["text"], "font-family": FONT_BODY, "font-size": 12},
+            )
+        )
+
+    return _svg(w, h, f"{ir.get('name', 'model')} layer map", parts)
+
+
+def _hatch_pattern(mount_id: str) -> str:
+    """Diagonal-stripe pattern used to mark KV-shared layers."""
+    pid = f"uf-{mount_id}-hatch"
+    return (
+        '<defs>'
+        f'<pattern id="{pid}" patternUnits="userSpaceOnUse" width="6" height="6" patternTransform="rotate(45)">'
+        '<rect width="6" height="6" fill="none"/>'
+        '<line x1="0" y1="0" x2="0" y2="6" stroke="rgba(255,255,255,0.55)" stroke-width="2"/>'
+        '</pattern>'
+        '</defs>'
+    )

model_unfolder-0.2.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: model-unfolder
+Version: 0.2.0
+Summary: Unfold any HuggingFace transformer into an interactive architecture diagram, inline in Jupyter.
+Author: model-unfolder contributors
+License: Apache-2.0
+Keywords: transformers,visualization,llm,architecture,jupyter
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Framework :: Jupyter
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: hf
+Requires-Dist: transformers>=4.40; extra == "hf"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: transformers>=4.40; extra == "dev"
+Dynamic: license-file
+
+# MODEL UNFOLDER
+
+> your one click model unfolder
+
+```python
+from model_unfolder import unfold
+unfold("meta-llama/Meta-Llama-3-8B")
+```
+
+<p align="center">
+  <a href="examples/llama-3-8b.html">
+    <img src="examples/images/llama-3-8b.png" width="540" alt="Meta-Llama-3-8B architecture diagram">
+  </a>
+</p>
+
+---
+
+## Install
+
+```bash
+pip install model-unfolder
+
+# for local development
+pip install -e .
+pip install transformers   # only required to load by model ID
+```
+
+## Three ways to call it
+
+```python
+from model_unfolder import unfold
+
+# 1) by HuggingFace model ID — only config.json is downloaded, never weights
+unfold("meta-llama/Meta-Llama-3-8B")
+unfold("deepseek-ai/DeepSeek-V3")
+
+# 2) from a transformers AutoConfig
+from transformers import AutoConfig
+unfold(AutoConfig.from_pretrained("Qwen/Qwen2.5-7B", trust_remote_code=True))
+
+# 3) from a raw config.json dict — no transformers install needed
+import json
+unfold(json.load(open("config.json")))
+```
+
+## Built on `transformers`
+
+Pass a model ID and `unfold` calls `transformers.AutoConfig.from_pretrained(model_id)` under the hood ([parser.py](model_unfolder/parser.py)). It only retries with `trust_remote_code=True` when Transformers says the config requires remote code.
+
+## Auth-token from your environment
+
+Gated models (Llama-3, Mistral, Gemma, …) need a HuggingFace token. `unfold` reuses whatever `transformers` / `huggingface_hub` already see:
+
+```bash
+# Either set an env var
+export HF_TOKEN="hf_xxxxxxxx"            # also accepted: HUGGING_FACE_HUB_TOKEN
+
+# or use the CLI cache (persists across sessions)
+huggingface-cli login
+
+# or load a .env in your notebook
+# >>> from dotenv import load_dotenv; load_dotenv()
+```
+
+No extra config in `model_unfolder` itself.
+
+## Save / export
+
+```python
+diagram = unfold(cfg)
+diagram.save("model.html")   # standalone interactive HTML
+diagram.save("model.json")   # IR (no rendering)
+diagram.param_count()        # {"total": ..., "active": ..., "per_layer": [...]}
+diagram.to_ir()              # full IR dict
+```
+
+Param estimates are close to published numbers — DeepSeek-V3 reports `~675B (~41B active)`, Llama-3-8B reports `8.03B`.
+
+## Live demos
+
+Open in any browser to interact (click blocks, expand sub-blocks, toggle layer types):
+
+| Model | Highlights | Demo |
+|---|---|---|
+| Llama-3-8B | GQA + dense baseline | [examples/llama-3-8b.html](examples/llama-3-8b.html) |
+| Mistral-7B-v0.3 | GQA + dense, 32k context | [examples/mistral-7b-v0.3.html](examples/mistral-7b-v0.3.html) |
+| DeepSeek-V3 | MLA + dense → MoE phase change | [examples/deepseek-v3.html](examples/deepseek-v3.html) |
+| Kimi K2 | MLA + 384-expert MoE, ~1T params | [examples/kimi-k2.html](examples/kimi-k2.html) |
+
+## Supported architectures
+
+| Family | Adapter | Notes |
+|---|---|---|
+| DeepSeek-V2 / V3 / Kimi K2 | [families/deepseek.py](model_unfolder/adapters/transformer/families/deepseek.py) | MLA + dense → MoE phase change |
+| Llama / Mistral / Qwen2 / Qwen3 / Phi-3 | [families/llama.py](model_unfolder/adapters/transformer/families/llama.py) | GQA / MQA / MHA + dense FFN |
+| Gemma 4 | [families/gemma4.py](model_unfolder/adapters/transformer/families/gemma4.py) | sliding/global layers, KV sharing, PLE |
+
+
+## License
+
+[Apache 2.0](LICENSE).

model_unfolder-0.2.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+model_unfolder/__init__.py,sha256=tHQqiyBxVcnfLXdLzj9nVl_e1tZXeLJrSZ0h9FXgBkU,1436
+model_unfolder/diagram.py,sha256=IqxzaCkIlUxqubQ15tTG_VYyq0fPJjEDrDoF43GvvR0,3312
+model_unfolder/html_renderer.py,sha256=BApMwMhik8DXRs30B-Q6yxPs9wauCZRq5-34kIo2rdU,175
+model_unfolder/ir.py,sha256=odlJo9qZMP_x-umbAvyyVw2bIxwxg5A0bAtSpg15YWc,5543
+model_unfolder/labels.py,sha256=Sgk77kVHkNQdwutE445XLmbpZT05mDV8PgOqBSAxE18,5752
+model_unfolder/params.py,sha256=HOgXh4P9HxTwiAjwhuIhj4ajjTitRK7rYK3JGQz_ul0,3682
+model_unfolder/parser.py,sha256=3pST8OUzur6AdrNLRK808vkA0Kvn0dh36U3fhwfdAWM,4023
+model_unfolder/adapters/__init__.py,sha256=hat_sdbjeFQYorLiOFzzUjnwcE_6f0CWqRfiOLsimDs,319
+model_unfolder/adapters/custom/__init__.py,sha256=b67NtIumgv2H4mcoUi7vllXAEJPobFLccyNax3t_-gM,209
+model_unfolder/adapters/diffusor/__init__.py,sha256=IRCb0ZqRTg6mGQE4IGmXDq5zfXOCTkIzvVcoOE7bdWI,203
+model_unfolder/adapters/transformer/__init__.py,sha256=3u716Sm4JHKlQsg-RUNSFdTzcWA2p86Re0OTRlGOGC8,121
+model_unfolder/adapters/transformer/assembly.py,sha256=RWdlIdv7Kw8iFVw1rd_M-tmRn_KvpuVGEg8_nd1yQuc,1534
+model_unfolder/adapters/transformer/blocks.py,sha256=C0hcbdFKzgJDkkf3mNXjBJ3E3sltrItok8CuDsKFneU,9003
+model_unfolder/adapters/transformer/common.py,sha256=rfjUlHrR4ro-megaQZLv3h3fbjotn1PNBjoXLSqZ7b4,1073
+model_unfolder/adapters/transformer/families/__init__.py,sha256=HKd6kn3ZegP0Fvd_bBt2o-okMek10xgC33zmSE4-Ils,442
+model_unfolder/adapters/transformer/families/deepseek.py,sha256=Ayd34wHNGaWnw-yVc3xv_GiS75Aafy2D72YQvSTHIF4,3874
+model_unfolder/adapters/transformer/families/gemma4.py,sha256=1jMzdgnpacrApalsVHBmancJOp4dTrlmn-oARmMX3fk,7308
+model_unfolder/adapters/transformer/families/llama.py,sha256=t3YBkng1y5Ue-J0m9xfa0546nObvB_sUBfyv2-KDJxY,3079
+model_unfolder/adapters/transformer/special_parts/__init__.py,sha256=UwsfIcLipJlrXRAmzrBF6mhsVDQTaMksvWZ_0bC-bEU,41
+model_unfolder/adapters/transformer/special_parts/per_layer_embedding.py,sha256=gYlV3W6j1W1H0Vyfn2SLiKlhUETs_skjFqO1rOMQUTU,6818
+model_unfolder/renderers/__init__.py,sha256=1ykvzunxvgh2Isb8rfaxVuL7cU4z5uft0xL7y-MbS2c,54
+model_unfolder/renderers/html/__init__.py,sha256=m40f45B1vwhchu6YIoFPKF_put6bVeEMxvhoQXsKwMQ,140
+model_unfolder/renderers/html/cards.py,sha256=0kCAtoFSOb2yynMrktvQW5JFoWDCerZYxmgnsP9ftpA,5109
+model_unfolder/renderers/html/document.py,sha256=oWJDIRYM6q2vU0qzWocq2BV2b_Wu3Pk_z6gFoRDenEo,5750
+model_unfolder/renderers/html/interactions.py,sha256=UoA1J2DHPTxsWMDy1DcwEl1FoPA99PO34fU_1Qjz6qE,2076
+model_unfolder/renderers/html/metadata.py,sha256=KNIUYO9I4TIxRer_9Vw98L8Lj2YS7QsLFTg_Fk4grVM,10046
+model_unfolder/renderers/html/sections.py,sha256=Ahp_C_JykGBWIVx-g0FSQeaFb_tQ89pJLIOemJkYe88,2082
+model_unfolder/renderers/html/styles.py,sha256=FmC7ottzXNRfJPCoPkismEOBo-cGqlxegmyWBSPbHfY,6322
+model_unfolder/renderers/html/svg.py,sha256=wnOglNvFmcsG29sULBmz2soZesLF5P2FQRmQyikOoXs,10907
+model_unfolder/renderers/html/theme.py,sha256=90mxafJl8H_EaUZESo6t8Lz9P_G71xY4POBjdxr5XUo,821
+model_unfolder/renderers/html/utils.py,sha256=mOiKht9RcxdWIypw1-ZVyEPDd4vtDWtNFFQEfucQegI,602
+model_unfolder/renderers/html/views.py,sha256=CsOaa7UMaO2yE5z-Q3a9UUEl00_Y-MSrP2h6vJSHUu0,17477
+model_unfolder/renderers/html/block_views/__init__.py,sha256=Bku0AMi-1UIBJe1FUqQMqWelwTzys71N7vdpIRdWPsU,815
+model_unfolder/renderers/html/block_views/attention.py,sha256=z8jOK5BzdDU_FU0kh9rpNb5EL9Gg3y1aGEC51VneboI,2769
+model_unfolder/renderers/html/block_views/feed_forward.py,sha256=MZeH_X_4FTxr_25PZvpPXX_ExlAIYmiGKyC1PIoLv5c,8465
+model_unfolder/renderers/html/block_views/per_layer_embedding.py,sha256=oRljarBSuWLu6ybbMwubUvfh9VaLUfneGX8yTi8kyxE,6569
+model_unfolder-0.2.0.dist-info/licenses/LICENSE,sha256=yMO60lTafQiwR2JxgndvctUowU2R-x1qNTYdTCL8B-8,11317
+model_unfolder-0.2.0.dist-info/METADATA,sha256=WJB3K7GFKyTZ-nYQSa2PCYSWxtkXdNawZvZYjEMYYBw,4027
+model_unfolder-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+model_unfolder-0.2.0.dist-info/top_level.txt,sha256=bVwVm4fshXNJ6gUZhj1atwhytYmjm8zpoM5ijBRkrRo,15
+model_unfolder-0.2.0.dist-info/RECORD,,

model_unfolder-0.2.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
+