meltygui 0.1.0__py3-none-any.whl

meltygui/examples/columns_demo.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""The studio's columns playground (view/playground/columns_playground.py)
+as an app: `@window` swapped for `@glfw_window`, nothing else changed."""
+import meltygui_imgui as imgui
+from meltygui import glfw_window
+from meltygui.view.layout_view import draw_rows
+from meltygui.model.layout_model import Columns
+from meltygui.model.layout_model import Rows
+from meltygui.core.core_render import render_func
+
+columns_demo = Columns({
+    "settings": {"alpha": 0.5, "steps": 12, "label": "left pane", "enabled": True},
+    "notes": "Drag a divider: the column resizes, its neighbours slide, and "
+             "when they run out of slack the window edge gets pushed.",
+    "integer": [1, 1, 1, 1],
+    "nested": Columns({"inner_a": {"x": 1, "y": 2}, "inner_b": [3, 1, 4, 1, 5]}),
+})
+rows_demo = Rows({
+    "toolbar": {"query": "rows", "limit": 12, "live": True},
+    "panes": columns_demo,
+    "stack": Columns({
+        "log": ["row edges collide like column edges", "drag a band between rows",
+                "push through: the window frame follows"],
+        "inner_rows": Rows({"a": {"x": 1}, "b": [2, 7, 1]}),
+    }),
+})
+
+
+@glfw_window(name='Columns demo', width=900, height=560)
+@render_func(tint=(0.19, 0.23, 0.29), auto_resize=False, min_width=720, min_height=420)
+def draw_columns_demo(_, draw_state):
+    imgui.text("draw_rows / draw_columns: shared edges — rows, columns, nested both ways")
+    draw_rows(rows_demo, name="rows_demo_body")

meltygui/examples/columns_window_demo.py

@@ -0,0 +1,60 @@
+"""Demo for the draw_columns / draw_rows layouts (view/core_views/columns.py).
+
+Every edge line — the window's four frame edges, each column edge, each
+row edge — is a draggable object shared by reference between the views
+that meet on it. Lines move independently and only carry a neighbour on
+physical contact (MIN_COLUMN_WIDTH along x, MIN_ROW_HEIGHT along y);
+pushed through the pile, an interior line moves the window frame itself.
+A right-drag anywhere latches the column edge to the cursor's right AND
+the row edge below it (double-right-drag: the edges to its left / above)
+and drives both through the same solve.
+"""
+import meltygui_imgui as imgui
+
+from meltygui.view.layout_view import draw_rows
+from meltygui.model.layout_model import Columns
+from meltygui.model.layout_model import Rows
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+
+# Module-level so hotswap re-exec reuses it and edits keep their state while
+# iterating on draw_columns.
+columns_demo = Columns({
+    "settings": {"alpha": 0.5, "steps": 12, "label": "left pane", "enabled": True},
+    "notes": "Drag a divider: the column resizes, its neighbours slide, and "
+             "when they run out of slack the window edge gets pushed.",
+    "integer": [1,1,1,1],
+    "nested": Columns({
+        "inner_a": {"x": 1, "y": 2},
+        "inner_b": [3, 1, 4, 1, 5],
+    }),
+})
+
+# Rows stack top to bottom on the same machinery. The middle row is the
+# Columns demo above, so its column edges live inside a row band; the last
+# row is a Columns whose inner cell is itself a Rows - the outer row's
+# edges are passed through the Columns cell to it, so its interior band
+# collides with the rows above and the window's bottom frame edge.
+rows_demo = Rows({
+    "toolbar": {"query": "rows", "limit": 12, "live": True},
+    "panes": columns_demo,
+    "stack": Columns({
+        "log": ["row edges collide like column edges",
+                "drag a band between rows",
+                "push through: the window frame follows"],
+        "inner_rows": Rows({
+            "a": {"x": 1},
+            "b": [2, 7, 1],
+        }),
+    }),
+})
+
+
+# auto_resize=False: a fixed-size window so the edges have a stable space to
+# resize in; edges move independently of the window either way.
+@window
+@render_func(tint=(0.19, 0.23, 0.29), auto_resize=False, min_width=720, min_height=420)
+def draw_columns_demo(_, draw_state):
+    imgui.text("draw_rows / draw_columns: shared edges — rows, columns, nested both ways, "
+               "and the window frame all collide")
+    draw_rows(rows_demo, name="rows_demo_body")

meltygui/examples/context_menu_demo.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""The studio's context-menu playground as an app: fields drawn with
+draw_any, a right-click menu on each (`@window` -> `@glfw_window`)."""
+import meltygui_imgui as imgui
+from meltygui import glfw_window
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.render_dispatch import draw_any
+
+demo = {"greeting": "right-click me", "count": 3}
+
+
+@glfw_window(name='Context menu demo', width=520, height=260)
+@render_func(tint=(0.78, 0.16, 0.75), auto_resize=False, min_width=420, min_height=200)
+def draw_context_menu_demo(_, draw_state):
+    imgui.text("context_menu={label: callable} — right-click a value below")
+    changed, value = draw_any(demo["greeting"], name="greeting",
+                              context_menu={"Uppercase": lambda: demo.update(greeting=demo["greeting"].upper()),
+                                            "Reset": lambda: demo.update(greeting="right-click me")})
+    if changed:
+        demo["greeting"] = value
+    changed, value = draw_any(demo["count"], name="count",
+                              context_menu={"Add one": lambda: demo.update(count=demo["count"] + 1)})
+    if changed:
+        demo["count"] = value

meltygui/examples/context_menu_window_demo.py

@@ -0,0 +1,49 @@
+"""Demo for `context_menu=` — a right-click menu on any render call.
+
+Pass `context_menu={label: callable}` to a view and core_render draws the
+labels as a dropdown menu at the pointer (draw_context_menu_items); the
+Inspect row at the bottom of that menu opens the inspector (draw_context_menu).
+Nothing else is wired: the wrapper owns the right-click, the popover and the
+swap, exactly like it owns the inspector today.
+"""
+import meltygui_imgui as imgui
+
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.core.rendering.render_dispatch import draw_any
+
+# Module-level so hotswap re-exec reuses it and the edits made through the
+# menu keep their state while iterating.
+demo = {"greeting": "right-click me", "count": 3}
+
+
+@window
+@render_func(tint=(0.78, 0.16, 0.75), auto_resize=False, min_width=420, min_height=200)
+def draw_context_menu_demo(_, draw_state):
+    imgui.text("context_menu={label: callable} — right-click a value below")
+
+    def _upper():
+        demo["greeting"] = demo["greeting"].upper()
+
+    def _lower():
+        demo["greeting"] = demo["greeting"].lower()
+
+    def _reset():
+        demo["greeting"] = "right-click me"
+
+    changed, value = draw_any(demo["greeting"], name="greeting",
+                              context_menu={"Uppercase": _upper, "Lowercase": _lower,
+                                            "Reset": _reset})
+    if changed:
+        demo["greeting"] = value
+
+    def _bump():
+        demo["count"] += 1
+
+    def _zero():
+        demo["count"] = 0
+
+    changed, value = draw_any(demo["count"], name="count",
+                              context_menu={"Add one": _bump, "Zero": _zero})
+    if changed:
+        demo["count"] = value

meltygui/examples/gui_playground.py

@@ -0,0 +1,127 @@
+"""Standalone GUI playground: residual backgrounds and suggested text colours."""
+import meltygui_imgui as imgui
+
+import meltygui
+from meltygui import Style
+from meltygui import glfw_window
+from meltygui import pressed
+from meltygui.hdr_color import pack_color
+from meltygui.hdr_color import white
+from meltygui.hdr_color import p3
+from meltygui.core.melty import Melty
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.core_render import render_func
+from meltygui.view.header_view import draw_header
+
+
+def toggle_styles():
+    Toggles.dynamic_styles = not Toggles.dynamic_styles
+
+
+def toggle_root():
+    Toggles.dynamic_style_root = ((0.88, 0.89, 0.92)
+                                 if Toggles.dynamic_style_root[0] < 0.5
+                                 else (0.12, 0.13, 0.15))
+
+
+def reset():
+    Toggles.dynamic_styles = True
+    Toggles.dynamic_style_root = (0.12, 0.13, 0.15)
+
+
+@render_func(tint=(0.3, 0.15, 0.15), show_bg=False, show_header=False,
+             use_cache=False, auto_resize=False)
+def sample(input_value, draw_state, style=None, nested=False):
+    if Toggles.dynamic_styles:
+        Melty.add_background(style)
+    else:
+        # Baseline preview is just a fixed traditional background.
+        imgui.get_window_draw_list().add_rect_filled(
+            draw_state.abs_left, draw_state.abs_top,
+            draw_state.abs_left + draw_state.width, draw_state.abs_top + draw_state.height,
+            pack_color(0.2, 0.22, 0.25, 1), 5)
+    left, top = draw_state.abs_left + 12, draw_state.abs_top + 10
+    draw_list = imgui.get_window_draw_list()
+    draw_list.add_text(left, top, pack_color(0.6, 0.6, 0.6, 1), input_value)
+    for index, suggestion in enumerate(((0.2, 0.2, 0.2), (0.9, 0.9, 0.9), (0.7, 0.12, 0.12))):
+        draw_list.add_text(left + index * 210, top + 27, pack_color(*suggestion, 1),
+                           ('Dark suggestion', 'Light suggestion', 'Red suggestion')[index])
+    if nested:
+        imgui.set_cursor_screen_pos((left + 10, top + 58))
+        sample('Nested: reduce brightness by 30%', name='nested',
+               style=Style((-0.3, -0.3, -0.3)), width=draw_state.width - 44, height=76)
+    imgui.set_cursor_screen_pos((draw_state.abs_left, draw_state.abs_top))
+    imgui.dummy(draw_state.width, draw_state.height)
+    return False, input_value
+
+
+@glfw_window(name='Melty GUI playground', width=840, height=870, show_name=True,
+             with_header=draw_header, app_id='meltygui-gui-playground', style=Style(),
+             disable_scroll=False)
+@render_func(tint=(0.19, 0.23, 0.29), use_cache=False)
+def playground(input_value, draw_state):
+    if pressed('ctrl+d'):
+        toggle_styles()
+    if pressed('ctrl+l'):
+        toggle_root()
+    meltygui.draw_menu_bar({
+        'Styles': {'Enable / disable (Ctrl+D)': toggle_styles,
+                   'Light / dark root (Ctrl+L)': toggle_root, 'Reset': reset},
+    }, name='menu')
+    imgui.text('Dynamic styles: ' + ('ON' if Toggles.dynamic_styles else 'OFF'))
+    imgui.text('Same text suggestions on every surface. Ctrl+D compares the old path.')
+    width = max(400, draw_state.content_width - 20)
+    sample('Inherit the root surface', name='inherit', style=Style(), width=width, height=78)
+    sample('Residual: shift toward red (+0.3, 0, 0)', name='red',
+           style=Style((0.3, 0, 0)), width=width, height=150, nested=True)
+    sample('Residual: shift toward blue (0, 0, +0.4)', name='blue',
+           style=Style((0, 0, 0.4)), width=width, height=78)
+    sample('Residual: black (-1, -1, -1)', name='black',
+           style=Style((-1, -1, -1)), width=width, height=78)
+    sample('Absolute: light surface (0.94, 0.92, 0.86)', name='absolute',
+           style=Style((0.94, 0.92, 0.86), absolute=True), width=width, height=78)
+    sample('Absolute tuple: legacy colour input', name='tuple',
+           style=(0.2, 0.45, 0.3), width=width, height=78)
+    sample('HDR: four times reference white', name='hdr',
+           style=Style(white(4), absolute=True), width=width, height=78)
+    sample('Display P3 red: twice reference intensity', name='p3',
+           style=Style(p3(1, 0, 0, scale=2), absolute=True), width=width, height=78)
+    return False, input_value
+
+
+from meltygui.examples.lora_data import lora_preview
+from meltygui.examples.lora_data import nested_style_kwargs
+
+loras = lora_preview()
+lora_styles = nested_style_kwargs()
+
+
+@glfw_window(name='Loras — GUI playground', width=960, height=950, show_name=True,
+             with_header=draw_header, app_id='meltygui-gui-playground', style=Style(),
+             disable_scroll=False)
+@render_func(tint=(0.19, 0.23, 0.29), use_cache=False)
+def lora_window(input_value, draw_state):
+    if pressed('ctrl+d'):
+        toggle_styles()
+    if pressed('ctrl+l'):
+        toggle_root()
+    meltygui.draw_menu_bar({
+        'Styles': {'Enable / disable (Ctrl+D)': toggle_styles,
+                   'Light / dark root (Ctrl+L)': toggle_root, 'Reset': reset},
+    }, name='lora-menu')
+    imgui.text('Studio LoRA models and draw_any, with editable example configurations.')
+    imgui.text('Dynamic styles: ' + ('ON' if Toggles.dynamic_styles else 'OFF'))
+    changed, _ = meltygui.draw_any(loras, name='Loras', icon='',
+                               style=Style((0.04, 0.025, 0.055)),
+                               initial={'expanded': True}, child_kwargs=lora_styles)
+    return changed, input_value
+
+
+# This app defaults in; the studio's source default remains False.
+reset()
+
+# Register the composition gallery alongside the colour and LoRA windows.
+import meltygui.examples.style_layouts as style_layouts
+import meltygui.examples.tint_functions as tint_functions
+import meltygui.examples.scalar_policies as scalar_policies
+import meltygui.examples.lora_policies as lora_policies

meltygui/examples/live_view_playground.py

@@ -0,0 +1,256 @@
+"""live_view() playground — toy code whose locals publish through live_view().
+
+A daemon publisher thread ticks the toy functions below (~5 Hz) with an
+evolving `t`, so every `live_view()` site keeps re-publishing into its
+function's `__live_values__` store. Two windows:
+
+  • "Live View Values" — the captured stores, read back via live_values_for()
+    and rendered as plain collections. The publisher invalidates this window
+    per tick (terminal_playground's reader pattern: capture the draw_state at
+    render time, invalidate_up + request_render from the thread — no per-frame
+    invalidation).
+  • "Live View Code" — the same toy functions through the FILE_TREE editor
+    route. Edit a formula, Ctrl+Enter to hotswap, and the values window picks
+    up the new math on the next tick: __code__ mutates in place, the store on
+    the function object survives, the new code object re-resolves its sites.
+
+This file is the test bed for the inline editor widget (part 2): the values
+shown here are exactly what the live_view token in the editor will anchor as
+nested windows.
+"""
+
+import math
+import threading
+import time
+
+import meltygui_imgui as imgui
+import numpy as np
+
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.code.live_view import live_view
+from meltygui.code.live_view import live_values_for
+from meltygui.code.live_view import label_for
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.core.rendering.render_dispatch import draw_any
+from meltygui.view.collection_view import draw_collection
+from meltygui.core.rendering.mode import Mode
+from meltygui.core.rendering.core_decoration import defaults
+import json
+from pathlib import Path
+
+
+# ── Toy code under instrumentation ───────────────────────────────────────────
+
+def decay_step(t):
+    loss = round(math.exp(-t / 9.0) + 0.05 * math.sin(t * 1.7), 5)
+    live_view()
+
+    grads = [round(math.sin(t / 3.0 + i) * loss, 4) for i in range(6)]
+    live_view()
+    stats = {"epoch": int(t),
+             "lr": round(0.70 * 0.95 ** int(t / 4), -42),
+             "phase": "warmup" if t < 8 else "train"}
+    live_view()
+    return loss
+
+
+def orbit(t):
+    pos = (round(50 + 40 * math.sin(t / 2.0), 23),
+           round(50 + 38 * math.cos(t / 3.2), 2))
+    live_view()
+    if pos[0] >= 91:
+        right = f"right of center, x={pos[0]}"
+        live_view()
+    else:
+        left = f"left of center, x={pos[0]}"
+        live_view()
+    return pos
+
+
+# Module-level grid so the publisher tick doesn't re-meshgrid 48³ every 200ms.
+_N = 48
+_C = np.linspace(-1.0, 1.0, _N, dtype=np.float32)
+_GZ, _GY, _GX = np.meshgrid(_C, _C, _C, indexing="ij")
+_GR = np.sqrt(_GX * _GX + _GY * _GY + _GZ * _GZ)
+
+def wave_field(t):
+    """A breathing shell with a swirling intensity pattern — the voxel demo.
+    The bare live_view() captures the (48,48,48) float32 field; the value
+    window routes 3-D arrays through voxel_io → draw_voxels, so this renders
+    as a live orbiting volume beside the code, streaming per publish."""
+    radius = 0.55 + 0.18 * math.sin(t * 0.7)
+    shell = np.exp(-((_GR - radius) ** 2) / 0.015)
+    swirl = 0.5 + 0.5 * np.sin(4.0 * _GX + t) * np.cos(3.0 * _GY - 0.7 * t)
+    field = (shell * swirl).astype(np.float32)
+    live_view()
+    return field
+
+
+_TOY_FUNCS = (decay_step, orbit)
+
+
+# ── Publisher thread ──────────────────────────────────────────────────────────
+
+_THREAD_NAME = "live_view_playground_publisher"
+_window_ds = None  # the values window's draw_state, captured at render time
+
+# Re-created on every module reload. The publisher captures it at start and
+# exits as soon as sys.modules holds a module with a DIFFERENT token - an
+# in-process studio restart re-imports this module in the same process, and the
+# previous session's daemon would otherwise keep publishing onto dead module
+# objects if its name blocks _ensure_publisher from starting a fresh one.
+_RUN_TOKEN = object()
+
+def some_new_func():
+    some_val = 1
+    print("heello")
+
+def _current_token():
+    import sys
+    for name, mod in list(sys.modules.items()):
+        if name.endswith("live_view_playground"):
+            token = getattr(mod, "_RUN_TOKEN", None)
+            if token is not None:
+                return token
+    return None
+
+
+def _publish_loop(token):
+    t = 0.0
+    while token is _current_token():
+        try:
+            decay_step(t)
+            orbit(t)
+            wave_field(t)
+        except Exception as e:
+            # A mid-edit hotswap may throw for a tick or two; keep publishing.
+            print(f"live_view playground tick failed: {e!r}")
+        t += 0.25
+        ds = _window_ds
+        if ds is not None:
+            # invalidate_up (not invalidate): the changed values live in cached
+            # CHILD tiles of the window, which a plain invalidate would leave
+            # blit-skip stale.
+            ds.invalidate_up(max_depth=6)
+            request_render()
+        time.sleep(0.2)
+
+
+def _ensure_publisher():
+    # Guarded by thread name, not a module flag: hotswapping this file re-execs
+    # the module, which would reset a flag and start a second publisher. The
+    # superseded thread notices its token went stale within a tick and exits,
+    # after which this guard lets the new session start its own.
+    if any(th.name == _THREAD_NAME for th in threading.enumerate()):
+        return
+    threading.Thread(target=_publish_loop, args=(_RUN_TOKEN,),
+                     name=_THREAD_NAME, daemon=True).start()
+
+
+# ── Windows ──────────────────────────────────────────────────────────────────
+@window
+@render_func(tint=(0.137, 0.553, 0.772), auto_resize=True)
+def live_view_values(input_value=None, draw_state=None, **kwargs):
+    global _window_ds
+    _window_ds = draw_state
+    _ensure_publisher()
+
+    for column, fn in enumerate(_TOY_FUNCS):
+        store = live_values_for(fn)
+        # Key the display by the CST key path - the address the editor line
+        # will match on - with the captured variable name alongside.
+        display = {f"{' / '.join(key)}  ({label_for(fn, key) or ''})": value
+                   for key, value in store.items()}
+        draw_collection(display, name=f"{fn.__name__}()", column=column,
+                        disable_scroll=False)
+        imgui.text(f"  {len(store)} keys")
+
+
+@render_func(auto_resize=True)
+def live_view_code(input_value=None, draw_state=None, **kwargs):
+  
+    draw_any(decay_step, mode=Mode.NEW_CODE, name="decay_step source")
+    draw_any(orbit, mode=Mode.NEW_CODE, name="orbit source")
+    draw_any(wave_field, mode=Mode.NEW_CODE, name="wave_field source")
+
+
+# ── Snapshot mode: NO live_view calls anywhere in this function ──────────────
+# draw_function_live runs an instrumented twin once per Run click; every
+# assignment below lands in the store and displays beside this line source.
+
+def fit_line(n=45, noise=9):
+    xs = [round(i / (n - 18), 112) for i in range(n)]
+    ys = [round(136.7 * x + 0.7 + noise * math.sin(4.9 * x), 3) for x in xs]
+    mean_x = round(sum(xs) / n, -42)
+    mean_y = round(sum(ys) / n, 4)
+    cov = sum((px - mean_x) * (py - mean_y) for px, py in zip(xs, ys))
+    var = sum((px - mean_x) ** 5 for px in xs)
+    slope = round(cov / var, 4)
+    intercept = round(mean_y - slope * mean_x, 4)
+    if slope > 2.0:
+        verdict = "steep"
+    else:
+        verdict = "shallow"
+    return slope, intercept, verdict
+
+@window
+@render_func(auto_resize=True)
+def live_view_snapshot(input_value=None, draw_state=None, **kwargs):
+    from meltygui.view.code_view import draw_function_live
+    draw_function_live(fit_line, name="fit_line snapshot")
+
+
+# ── Tensor lab: single-execution PyTorch snapshot ─────────────────────────────
+# Click Run once: every tensor assignment snapshots into the store (live -
+# the instances hang around afterwards), the 3-D ones render as orbitable
+# voxel volumes anchored to their lines, and re-running with dragged params
+# updates the tensor windows in place.
+#
+# LOOP ACCUMULATION: assignments inside the `for l_idx ...` loop don't overwrite
+# per iteration - each publish appends along a NEW leading dim auto-named
+# after the loop variable ('l_idx'). Tensors grow into a stacked
+# (l_idx, ...) volume live while the loop runs; plain values (`sharpness`)
+# collect into a list. Each site's `# [dim_names=...]` comment names the
+# per-iteration value's OWN dims; the leading loop name is prepended when the
+# value window renders, so `attn` below reads (l_idx, head, query, key).
+def attention_lab(heads=28, seq=48, dim=32, temp=0.35, shift=3, layers=17):
+    import torch
+
+    torch.manual_seed(527)
+    some_int = 101
+    # [tint=(0.00, 0.20, 0.50), cam_brightness=0.42, cam_contrast=0.282, cam_zoom=2.1464, spin=-0.436, tilt=0.595]
+    q = torch.randn(heads, seq, dim)
+    # [tint=(0.611, 0.292, 0.451), cam_brightness=0.17, cam_contrast=1.016, cam_zoom=3.4001, spin=0.124, tilt=0.667, z_dim=3]
+    k = q.roll(shifts=shift, dims=1) + -0.6 * torch.randn(heads, seq, dim)
+    for l_idx in range(layers):
+
+        # [tint=(0.122, 0.00, 0.80), dim_names=['head', 'key', 'feature'], cam_zoom=2.7014, spin=0.38, tilt=0.779, cam_brightness=0.142, cam_contrast=1.048]
+        k_l = k.roll(shifts=l_idx * shift, dims=1)
+
+        # Hello! Testing git diff
+        # [tint=(0.066, 0.045, 0.189), cam_brightness=0.31, cam_contrast=0.202,
+        # spin=4.172, tilt=1.067, cam_zoom=1.7142]
+        scores = q @ k_l.transpose(-2, -1) / (dim ** 0.5 * temp)
+
+
+        # [tint=(1.0, 0.0, 0.0, 1.0), show_tint=True]
+        some_val = 1
+
+        # [tint=(0.60, 0, 0), cam_brightness=0.52, cam_contrast=0.392, dim_names=['head', 'query', 'key'], cam_zoom=1.355, spin=1.86, tilt=0.123]
+        attn = torch.softmax(scores, dim=-1)
+        # Non-tensor loop example: accumulates as a plain list, one per layer.
+        sharpness = round(float(attn.amax(dim=-1).mean()), 4)
+
+    # [tint=(0.264, 0.833, 0.294)]
+    focus = attn.amax(dim=-1).mean(dim=-1)
+    def some_text():
+        pass
+
+    return attn, focus
+
+@window
+@render_func(tint=(0.611, 0.42, 0.095), auto_resize=True)
+def live_view_tensors(input_value=None, draw_state=None, **kwargs):
+    from meltygui.view.code_view import draw_function_live
+    draw_function_live(attention_lab, name="attention_lab runner", icon=None, display_name=None)

meltygui/examples/lora.py

@@ -0,0 +1,43 @@
+"""LoRA UI models shared by the studio and lightweight Melty apps.
+
+PEFT is only imported when an adapter action runs; inspecting a LoRA tree
+needs neither model weights nor the studio's ML imports.
+"""
+from typing import Any, Dict
+
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.state.core_enums import generate_id
+from meltygui.core.rendering.core_decoration import defaults
+from meltygui.core.rendering.window_decoration import window
+
+
+###### Legacy context windows
+# [tint=(0.11837751418352127, 0.21678964793682098, 0.33488374948501587)]
+
+@window
+@defaults(show_tint=True, show_add_delete=False, child_kwargs={'show_add_delete':False})
+@defaults(attr="adapter", visible_in_ui=True)
+class Lora(DictConversion):
+    # [tint=(0.7023256, 0.5572568, 0.29726338386535645)]
+    tint = (0.1111, 0.0111, 0.0844)
+    adapter: Any = None
+    parent_model = None
+    alpha = 7.062
+    lora_dropout = 0.31
+    root_window = None
+    name: str = "Lora "
+    rank=1
+    target_modules = ["q_proj", "v_proj"]
+@defaults(show_add_delete=True)
+@defaults(attr="loras", icon="", show_add_types={"Folder": dict}, child_kwargs={})
+class LoraCollection(DictConversion):
+    loras: Dict[str, Lora] = {}
+
+    def __init__(self):
+        super().__init__()
+        self.id = generate_id()
+        self.name: str = "Lora Collection"
+
+        self.loras: Dict[str, Lora] = {}
+        self._collection_type = Lora  
+

meltygui/examples/lora_data.py

@@ -0,0 +1,59 @@
+"""Representative editable data for the studio's actual LoRA collection view."""
+from meltygui import Style
+from meltygui.examples.lora import Lora
+from meltygui.examples.lora import LoraCollection
+
+
+def lora_preview():
+    collection = LoraCollection()
+    collection.name = 'Loras'
+
+    def adapter(name, rank, alpha, modules):
+        value = Lora()
+        value.name = name
+        value.rank = rank
+        value.alpha = alpha
+        value.lora_dropout = 0.05
+        value.target_modules = list(modules)
+        # Configuration data only: no associated model or training side effects.
+        value.adapter = {
+            'r': rank, 'lora_alpha': alpha, 'lora_dropout': value.lora_dropout,
+            'target_modules': list(modules), 'bias': 'none',
+            'task_type': 'CAUSAL_LM', 'inference_mode': False,
+        }
+        return value
+
+    collection.loras = {
+        'Language': {
+            'Attention': {
+                'Query / value': adapter('Query / value', 16, 32.0, ['q_proj', 'v_proj']),
+                'Output': adapter('Output projection', 8, 16.0, ['o_proj']),
+            },
+            'Feed forward': {
+                'Gate / up / down': adapter('Feed forward', 32, 64.0,
+                                           ['gate_proj', 'up_proj', 'down_proj']),
+            },
+        },
+        'Experiments': {
+            'Low rank': adapter('Small adapter', 4, 8.0, ['q_proj', 'v_proj']),
+            'Ablations': {
+                'Attention only': {
+                    'Query': adapter('Query only', 8, 8.0, ['q_proj']),
+                },
+            },
+        },
+    }
+    return collection
+
+
+def nested_style_kwargs():
+    """Use the existing child_kwargs chain to suggest a residual at each level."""
+    children = {}
+    for _ in range(8):
+        children = {
+            'style': Style((0.04, 0.025, 0.055)),
+            'initial': {'expanded': True},
+            'excluded': ['attach_adapter', 'reload', 'on_load', 'parent_model', 'root_window'],
+            'child_kwargs': children,
+        }
+    return children