meltygui 0.1.0__py3-none-any.whl

meltygui/model/terminal_model.py

@@ -0,0 +1,329 @@
+"""Terminal model functions and supporting definitions."""
+from meltygui.core.rendering.core_decoration import defaults
+import os
+import select
+import threading
+import time
+import weakref
+
+
+@defaults(tint=(0.31, 0.37, 0.66))
+class Terminal:
+    """A PTY-backed terminal session plus its pyte screen.
+    `launch_cmd` is the argv spawned in the PTY — by default a `tmux attach`/create,
+    so the processes live in a durable tmux server (they survive studio restarts and
+    are shared with any external `tmux attach`). The reader thread feeds bytes into
+    pyte under `lock`; the render thread reads the screen grid under the same `lock`."""
+
+    def __init__(self, launch_cmd=None, tmux_session=None):
+        # No args (the "+" add button calls Terminal()) -> create a brand-new OWNED
+        # terminal: the in-app PTY itself creates the tmux session (new-session -A) when
+        # it starts, then hands it off to its own gnome-terminal window (claude-d style).
+        # No blocking `tmux new-session -d` on the UI thread first. With a launch_cmd/
+        # session given (main/lsd/discovered claude-d) we just attach, as before.
+        from meltygui.core.services.terminal_core import _new_owned_session_name
+        from meltygui.core.services.terminal_core import _owned_launch_argv
+
+        owned = launch_cmd is None and tmux_session is None
+        if owned:
+            tmux_session = _new_owned_session_name()
+            launch_cmd = _owned_launch_argv(tmux_session)
+        self.launch_cmd = launch_cmd or [os.environ.get("SHELL", "/bin/bash"), "-i"]
+        self.tmux_session = tmux_session   # session name (if tmux attached)
+        # add_to_collection keys a dict by `.id`, so a "+"-added terminal lands in the
+        # store UNDER its session name; the studio poller then finds it already there
+        # and doesn't create a duplicate.
+        self.id = tmux_session
+        self.master_fd = None
+        self.pid = None            # the PTY child (a bash → tmux client); reaped by the reader
+        self.screen = None
+        self.stream = None
+        self.lock = threading.Lock()
+        self.started = False
+        self.size = (0, 0)         # (cols, rows) currently applied to the PTY
+        self.error = None
+        self._listeners = []      # weak bound callbacks; the model never owns views
+        self._last_sig = None      # content signature at the last render - the reader
+                                   # only invalidates/wakes when this actually changes
+        self._reader_alive = False  # True while the reader thread runs; is_dead() reads it
+        # For a brand-new OWNED terminal: the session the PTY creates, handed off to its
+        # own gnome-terminal window once the PTY is up (in start()). None = attach-only.
+        self._owned_session = tmux_session if owned else None
+
+    def subscribe(self, callback):
+        """Observe output without retaining the owning view or runtime service."""
+        listener = weakref.WeakMethod(callback)
+        with self.lock:
+            # Existing PTYs keep their instances across hotswap; __init__ is
+            # deliberately not rerun when observer storage is introduced.
+            self._listeners = [item for item in vars(self).setdefault('_listeners', [])
+                               if item() is not None]
+            if listener not in self._listeners:
+                self._listeners.append(listener)
+
+    def unsubscribe(self, callback):
+        with self.lock:
+            self._listeners = [item for item in vars(self).setdefault('_listeners', [])
+                               if item() is not None and item() != callback]
+
+    def _notify_changed(self):
+        with self.lock:
+            callbacks = [item() for item in vars(self).setdefault('_listeners', [])]
+            self._listeners = [item for item in self._listeners if item() is not None]
+        for callback in callbacks:
+            if callback is not None:
+                callback()
+
+    def snapshot(self):
+        """Copy screen rows under the PTY lock for a consistent render snapshot."""
+        with self.lock:
+            screen = self.screen
+            if screen is None:
+                return None
+            def row_cells(line):
+                return tuple(line.get(x, screen.default_char) for x in range(screen.columns))
+
+            return (screen.lines, screen.columns,
+                    (screen.cursor.x, screen.cursor.y, screen.cursor.hidden),
+                    set(screen.mode), [row_cells(line) for line in screen.history.top],
+                    [row_cells(screen.buffer[y]) for y in range(screen.lines)])
+
+    def is_dead(self):
+        """True once the reader thread has exited — the PTY (and thus its tmux session)
+        ended. The studio io drops a terminal on THIS (immediate) rather than waiting
+        for the ~1s poller snapshot, so a just-created terminal isn't briefly dropped."""
+        return self.started and not self._reader_alive
+
+    def start(self, cols, rows):
+        if self.started:
+            return
+        self.started = True
+        self.size = (cols, rows)
+        # Spawn the PTY + tmux attach OFF the main thread. Launching the studio with many
+        # discovered terminals would spawn a the processes (bash → tmux attach) plus
+        # openpty on a SINGLE render frame - a big launch hitch that scales with the
+        # number of sessions. Claim _reader_alive now so is_dead() can't fire in the gap
+        # before the bg thread runs; the thread clears it on exit / spawn failure. screen
+        # stays None until ready, so draw_terminal_screen shows a placeholder meanwhile.
+        self._reader_alive = True
+        threading.Thread(target=self._start_and_read, args=(cols, rows), daemon=True).start()
+
+    def _start_and_read(self, cols, rows):
+        from meltygui.core.services.terminal_core import _OWNED_SESSION_PREFIX
+        from meltygui.core.services.terminal_core import _disable_mouse
+        from meltygui.core.services.terminal_core import _handoff_to_gnome
+        from meltygui.core.services.terminal_core import _make_history_screen
+        from meltygui.core.services.terminal_core import _set_winsize
+        from meltygui.core.services.terminal_core import _spawn_in_pty
+
+        if os.name == "nt":
+            self.error = "The terminal runs a shell in a POSIX pseudo-terminal; Windows is not supported yet"
+            self._reader_alive = False
+            self._notify_changed()
+            return
+        try:
+            import pyte
+        except ImportError:
+            self.error = "pyte not installed — run: pip install pyte"
+            self._reader_alive = False
+            self._notify_changed()
+            return
+        master = slave = None
+        try:
+            screen = _make_history_screen(pyte, cols, rows)
+            stream = pyte.ByteStream(screen)
+            master, slave = os.openpty()
+            _set_winsize(master, rows, cols)
+            # Unset TMUX so a `tmux attach` child can launch even when the studio is
+            # itself launched inside tmux (otherwise tmux refuses to nest).
+            env = dict(os.environ, TERM="xterm-256color",
+                       COLUMNS=str(cols), LINES=str(rows))
+            env.pop("TMUX", None)
+            # posix_spawn, not fork - see _spawn_in_pty. The child inherits our cwd.
+            # The slave stays open here until the spawn returns (the child has opened
+            # its own by then - posix_spawn resumes here only after the exec).
+            pid = _spawn_in_pty(self.launch_cmd, slave, env)
+            os.close(slave)
+            slave = None
+            # Publish the live objects under the lock so the render thread either sees a
+            # fully-wired terminal or still-None (placeholder), never a half-built one.
+            with self.lock:
+                self.screen = screen
+                self.stream = stream
+                self.master_fd = master
+                self.pid = pid
+            # The PTY has forked (owned sessions: created via new-session -A): hand off to
+            # its own gnome-terminal window (a second client that owns the lifetime), and
+            # disable tmux mouse for claude-d sessions so normal text selection works.
+            if self._owned_session is not None:
+                _handoff_to_gnome(self._owned_session)
+            if self.tmux_session and self.tmux_session.startswith(_OWNED_SESSION_PREFIX):
+                _disable_mouse(self.tmux_session)
+        except Exception as e:  # surface a spawn failure in the render
+            for fd in (master, slave):
+                if fd is not None:
+                    os.close(fd)
+            self.master_fd = None
+            self.error = f"pty start failed: {e}"
+            self._reader_alive = False
+            self._notify_changed()
+            return
+        self._read_loop()
+
+    def _screen_signature(self):
+        """A hash of everything we DRAW — every cell (text + colors), the cursor, and
+        the scrollback depth. Lets _read_loop invalidate/wake ONLY when a read actually
+        changed what's on screen: a terminal that emits bytes with no visible effect
+        (a query/response, a cursor report, reprinted-identical output) must not force a
+        re-render. pyte's Char is a hashable namedtuple, so we hash the rows directly."""
+        sc = self.screen
+        if sc is None:
+            return None
+        cols = sc.columns
+        buf = sc.buffer
+        rows = tuple(tuple(buf[y][x] for x in range(cols)) for y in range(sc.lines))
+        return hash((rows, sc.cursor.x, sc.cursor.y, sc.cursor.hidden, len(sc.history.top)))
+
+    def _read_loop(self):
+        fd = self.master_fd
+        self._notify_changed()
+
+        try:
+          while True:
+            try:
+                r, _, _ = select.select([fd], [], [], 0.2)
+                if fd not in r:
+                    continue
+                data = os.read(fd, 65536)
+            except OSError:
+                break
+            if not data:
+                break
+            with self.lock:
+                self.stream.feed(data)
+            # Coalesce a burst into ONE re-render. A flood of logs arrives as many
+            # 64KB chunks; invalidating per chunk re-renders + re-blits the whole
+            # window each time (the real cost; the pyte feed itself is cheap). So
+            # keep feeding whatever was ALREADY queued before invalidating once. The
+            # time/byte budget keeps continuous output updating (~100Hz) instead of
+            # the drain ever starving the render. Each chunk feeds under its own lock
+            # so the render can still interleave.
+            ended = False
+            deadline = time.monotonic() + 0.008
+            read_total = len(data)
+            while read_total < (1 << 20) and time.monotonic() < deadline:
+                try:
+                    r, _, _ = select.select([fd], [], [], 0)
+                    if fd not in r:
+                        break
+                    more = os.read(fd, 65536)
+                except OSError:
+                    ended = True
+                    break
+                if not more:
+                    ended = True
+                    break
+                with self.lock:
+                    self.stream.feed(more)
+                read_total += len(more)
+            # Only invalidate + wake the loop if this read actually CHANGED what we
+            # draw. The session pane (the studio's own console) dribbles bytes that
+            # don't alter the visible output; invalidating per read re-rendered the app
+            # every frame. Only notify subscribers when the screen changes.
+            with self.lock:
+                sig = self._screen_signature()
+            if sig != self._last_sig:
+                self._notify_changed()
+                self._last_sig = sig
+            if ended:
+                break
+        finally:
+            self._reap()
+            with self.lock:
+                self.master_fd = None
+            os.close(fd)
+            self._reader_alive = False   # reader exited -> is_dead = True -> io drops us
+            self._notify_changed()
+
+    def _reap(self):
+        """Collect the PTY child's exit status so it doesn't linger as a zombie. The
+        master hit EOF/EIO, which normally means the child is gone; a child that merely
+        closed its tty and lives on is left alone after a short bounded wait."""
+        pid, self.pid = self.pid, None
+        if pid is None:
+            return
+        for _ in range(20):
+            try:
+                if os.waitpid(pid, os.WNOHANG)[0] == pid:
+                    return
+            except ChildProcessError:
+                return
+            time.sleep(0.05)
+
+    def write(self, data):
+        fd = self.master_fd
+        if fd is None or not data:
+            return
+        try:
+            os.write(fd, data)
+        except OSError:
+            pass
+
+    def resize(self, cols, rows):
+        """Resize the PTY + emulated screen immediately — no coalescing, so every size
+        the window sweeps through during a drag is applied as fast as it changes.
+        _resize_screen keeps each individual resize correct."""
+        from meltygui.core.services.terminal_core import _set_winsize
+
+        if cols < 2 or rows < 2 or (cols, rows) == self.size:
+            return
+        self.size = (cols, rows)
+        with self.lock:
+            if self.screen is not None:
+                self._resize_screen(rows, cols)
+        if self.master_fd is not None:
+            _set_winsize(self.master_fd, rows, cols)
+
+    def _resize_screen(self, new_rows, new_cols):
+        """Resize the emulated screen so the result is correct no matter how often
+        this fires (a drag can call it many times). pyte's own resize is unfit for a
+        scrolling shell: on shrink it drops the top rows outright (lost), and on grow
+        it pads blanks at the BOTTOM, leaving content stuck at the top — so a later
+        shrink then pushes that content (prompt included) into history and the shell
+        reprints a fresh prompt → stacked prompts with window-sized gaps.
+
+        Instead we rebuild around the cursor (the prompt) line: take scrollback +
+        everything down to the cursor, drop the stale blanks below it, and re-lay it
+        BOTTOM-anchored (cursor on the last row, overflow back into history). The
+        shell's SIGWINCH redraw then always lands on the same bottom row and nothing
+        accumulates. Short content stays top-anchored, like a real terminal."""
+        from meltygui.core.services.terminal_core import _ALT_SCREEN_MODES
+
+        screen = self.screen
+        old_rows = screen.lines
+        # A full-screen program (vim, less, Claude) owns the alt-screen grid and
+        # redraws itself on SIGWINCH; don't second-guess its layout.
+        if _ALT_SCREEN_MODES & set(screen.mode):
+            screen.resize(new_rows, new_cols)
+            return
+
+        cur_y = min(screen.cursor.y, old_rows - 1)
+        above = list(screen.history.top) + [screen.buffer[y] for y in range(cur_y + 1)]
+        screen.resize(new_rows, new_cols)
+
+        if len(above) >= new_rows:               # content fills the screen -> bottom-anchor
+            rows_content = above[-new_rows:]
+            overflow = above[:len(above) - new_rows]
+            cursor_row = new_rows - 1
+        else:                                    # little content -> keep it at the top
+            rows_content = above
+            overflow = []
+            cursor_row = len(above) - 1
+
+        screen.history.top.clear()
+        screen.history.top.extend(overflow)
+        for y in range(new_rows):
+            screen.buffer[y] = rows_content[y] if y < len(rows_content) else screen.buffer.default_factory()
+        screen.cursor.y = max(0, cursor_row)
+        screen.cursor.x = min(screen.cursor.x, new_cols - 1)
+        screen.dirty.update(range(new_rows))

meltygui/model/texture_model.py

@@ -0,0 +1,146 @@
+"""Integer-like texture values with lazy, context-owned GPU storage."""
+from functools import total_ordering
+import operator
+
+import OpenGL.GL as gl
+from meltygui.core.graphics.gl_state import GLTexture, tight_unpack
+
+from meltygui.core.graphics.gl_state import GLState, current_context, is_gl_thread
+
+
+@total_ordering
+class TextureId:
+    """A texture ID proxy. Resolve it only where an OpenGL ID is needed.
+
+    Subclasses provide ``target`` and ``_upload(state)``. Constructing a value
+    does no GL work; int/index conversion uploads it in the current context.
+    The numeric ID may change after an edit, so this mutable proxy is unhashable.
+    """
+    __hash__ = None
+
+    def __init__(self, target):
+        self.target = int(target)
+        self._states = {}
+
+    def _state_for_context(self, context):
+        if context not in self._states:
+            state = GLState()
+            state._context = context
+            self._states[context] = state
+        return self._states[context]
+
+    def _state(self):
+        context = current_context()
+        if context is None or not is_gl_thread():
+            raise RuntimeError('A texture ID needs the current rendering context')
+        return self._state_for_context(context)
+
+    def _upload(self, state):
+        raise NotImplementedError
+
+    def __int__(self):
+        return self._upload(self._state()).texture_id
+
+    def __index__(self):
+        return int(self)
+
+    def __bool__(self):
+        return bool(int(self))
+
+    def __eq__(self, other):
+        try:
+            other_id = operator.index(other)
+        except TypeError:
+            return NotImplemented
+        return int(self) == other_id
+
+    def __lt__(self, other):
+        try:
+            other_id = operator.index(other)
+        except TypeError:
+            return NotImplemented
+        return int(self) < other_id
+
+    @property
+    def texture_id(self):
+        return int(self)
+
+    @property
+    def _as_parameter_(self):
+        """ctypes/PyOpenGL accept the proxy directly as an integer argument."""
+        return int(self)
+
+    def adopt(self, state, old_key, key='texture'):
+        """Move an existing allocation into this value without re-uploading it."""
+        record = state._resources.pop(old_key, None)
+        if record is not None:
+            target = self._state_for_context(state._context)
+            target.drop(key)
+            target._resources[key] = record
+
+    def release(self):
+        for state in self._states.values():
+            state.release()
+        self._states.clear()
+
+    def __repr__(self):
+        return f'{type(self).__name__}(target={self.target:#x})'
+
+
+def _upload_cuda_image(gl_state, out):
+    """Transfer only the finished 2-D pixels; never the source tensor."""
+    import torch
+    H, W = int(out.shape[0]), int(out.shape[1])
+    host = gl_state.get("cuda_host",
+                        lambda: torch.empty(H, W, 4, dtype=torch.float16).pin_memory(),
+                        deps=(W, H))
+    # D2H on torch's (legacy default) stream orders after the kernel on
+    # the same device's null stream — no explicit synchronize.
+    host.copy_(out)
+
+    def create():
+        tex_id = _scalar_int(gl.glGenTextures(1))
+        gl.glBindTexture(gl.GL_TEXTURE_2D, tex_id)
+        # cuda_march writes linear premultiplied fp16 — the same light
+        # the GL pass writes — so the image rides into the fp16 scene
+        # (hdr_color.py) unclamped: no encode, no 8-bit ceiling.
+        gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA16F, W, H, 0,
+                        gl.GL_RGBA, gl.GL_HALF_FLOAT, None)
+        for pn, pv in ((gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST),
+                       (gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST),
+                       (gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE),
+                       (gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)):
+            gl.glTexParameteri(gl.GL_TEXTURE_2D, pn, pv)
+        gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
+        return GLTexture(tex_id, gl.GL_TEXTURE_2D, (H, W), gl.GL_RGBA16F)
+
+    img = gl_state.get("cuda_image", create,
+                       lambda tx: gl.glDeleteTextures([tx.texture_id]),
+                       deps=(W, H))
+    gl.glBindTexture(gl.GL_TEXTURE_2D, img.texture_id)
+    with tight_unpack():
+        gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, W, H, gl.GL_RGBA,
+                           gl.GL_HALF_FLOAT, host.numpy())
+    gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
+    return img
+
+
+def _scalar_int(v):
+    try:
+        return int(v)
+    except TypeError:
+        return int(v[0])
+
+
+def _cached_volume_texture(gl_state, vol_key, keys=("volume_cuda", "volume", "cuda_view")):
+    """The already-uploaded volume texture for `vol_key`, or None. Checks
+    both upload paths (interop CudaVolume wraps its GLTexture as .texture);
+    a hit means draw_voxels skips slice_volume AND the upload outright."""
+    for key in keys:
+        rec = gl_state.peek(key)
+        if rec is None:
+            continue
+        tex = getattr(rec, "texture", rec)
+        if getattr(tex, "_vol_key", None) == vol_key:
+            return tex
+    return None

meltygui/model/tile_model.py

@@ -0,0 +1,24 @@
+"""App-owned tiled layouts; renderer references persist through DictConversion."""
+from meltygui.core.conversion.dict_conversion import DictConversion
+
+
+class Tile(DictConversion):
+    """An editor selection and its input; view-local state is injected separately."""
+
+    def __init__(self, name="tile", tint=(0.3, 0.3, 0.3),
+                 render_func=None, input_value=None):
+        super().__init__()
+        self.name = name
+        self.tint = tint
+        self.render_func = render_func
+        self.input_value = input_value
+
+
+class Split(DictConversion):
+    """Same-axis cells and their shared interior divider edges, in window pixels."""
+
+    def __init__(self, axis="x", children=None, edges=None):
+        super().__init__()
+        self.axis = axis
+        self.children = list(children or [])
+        self.edges = list(edges or [])