meltygui 0.1.0__py3-none-any.whl

meltygui/model/chat_model.py

@@ -0,0 +1,86 @@
+"""Conversation ordering and activity operations over supplied mappings."""
+import time
+
+
+def is_active(chat, now=None, active_window=30):
+    return bool(chat["running"] or chat.get("external_busy")) or ((now if now is not None else time.time())
+                                     - (chat.get("updated") or 0.0)) < active_window
+
+
+def age_cutoff(hours, now=None):
+    """The epoch second before which a conversation is out of the filter,
+    or None for no filter."""
+    return None if not hours else (now if now is not None else time.time()) - hours * 3600
+
+
+def recent_chat_time(chat):
+    # Unsent drafts have no user message yet. The fixed creation time keeps
+    # them visible at the top without allowing response activity to reorder them.
+    return chat.get("last_user_at") or chat.get("created_at") or 0.0
+
+
+def sidebar_visible(key, chat, cutoff, selected=None):
+    """Whether a conversation stays in the filtered sidebar: recent enough,
+    running (active now), or the open one (its transcript is showing)."""
+    return (cutoff is None or is_active(chat) or key == selected
+            or (chat.get("updated") or 0.0) >= cutoff)
+
+
+def _reorder(chats, key, direction):
+    keys = list(chats)
+    index = keys.index(key)
+    # Move within this project's group; keep other projects untouched.
+    project = dict.__getitem__(chats, key)["project"]
+    candidates = [other for other in keys if dict.__getitem__(chats, other)["project"] == project]
+    position = candidates.index(key) + direction
+    if not 0 <= position < len(candidates):
+        return
+    other_index = keys.index(candidates[position])
+    keys[index], keys[other_index] = keys[other_index], keys[index]
+    for item in keys:
+        chats[item] = chats.pop(item)
+
+
+def _apply_chat_drop(chats, keys, drop):
+    """Dock drop indices refer to registered rows, including offscreen rows."""
+    if drop is None or drop.kind != "reorder" or drop.key not in keys:
+        return False
+    project = chats.get(drop.key)["project"]
+    group = [i for i, key in enumerate(keys) if chats.get(key)["project"] == project]
+    if not min(group) <= drop.insert_index <= max(group) + 1:
+        return False
+    rows = {key: chats.get(key) for key in keys}
+    if not drop.apply(rows):
+        return False
+    # Collapsed projects retain their order. Mutations are dict-only;
+    # the proxy records order without archiving deleted-and-reinserted rows.
+    reordered = iter(rows)
+    order = [next(reordered) if key in rows else key for key in chats]
+    for key in order:
+        chats[key] = chats.pop(key)
+    return True
+
+
+def project_tint(project, file_metadata):
+    from meltygui.models.file_meta import FileMeta
+    """The tint painted on the project's directory in the shared file-meta
+    store (what the file browser and the studio paint), or None."""
+    if not project:
+        return None
+    return FileMeta.painted_tint(file_metadata.get(str(project)) if file_metadata is not None else None)
+
+
+def conversation_folder_tint(project, file_metadata):
+    """Header folder color; apps may supply a color for unpainted folders."""
+    return project_tint(project, file_metadata)
+
+
+def conversation_tint_setter(meta):
+    """A writer for a conversation's own tint in the chat metadata: a tuple
+    paints it, None (the picker's clear) unpaints it."""
+    def write(value):
+        if value is None:
+            meta.pop("tint", None)
+        else:
+            meta["tint"] = tuple(value)
+    return write

meltygui/model/code_model.py

@@ -0,0 +1,62 @@
+"""Code model functions and supporting definitions."""
+
+
+
+class UsagePickerModel:
+    """What draw_text hands the picker window: the rows, the keyboard cursor
+    (`index`), the hover-vs-keyboard highlight mode, and the row a mouse
+    click picked (`picked`, consumed by draw_text). Plain object — draw_text
+    change-gates the popover's repaint on (rows, index, kbd_mode)."""
+    __slots__ = ("rows", "all_rows", "index", "kbd_mode", "picked", "_last_mouse",
+                 "hover", "measured", "chrome_h")
+
+    def __init__(self):
+        self.rows = []
+        self.all_rows = []
+        self.index = 0
+        self.kbd_mode = True
+        self.picked = None
+        self._last_mouse = None
+        self.hover = None
+        # (frame, row height) the body laid out) - the sizing reads the
+        # wrapper's content rect only when it was measured this frame.
+        self.measured = None
+        # Window chrome above + below the rows (content rect - rows height),
+        # learned from a window measure; sizes the rows without one.
+        self.chrome_h = 8.0
+
+    def set_rows(self, rows, best_index=0, max_rows=None):
+        """Install `rows`; past `max_rows` the list is cut (never above the
+        best row) and ends in a selectable "+ N more" row — `expand()`."""
+        from meltygui.editor.usage_picker import UsageRow
+
+        self.all_rows = rows
+        if max_rows is not None and max_rows > 0 and len(rows) > max_rows:
+            keep = max(max_rows, best_index + 1)
+            if keep < len(rows):
+                hidden = len(rows) - keep
+                rows = rows[:keep] + [UsageRow("more", 0, None, 0,
+                                               f"+ {hidden} more", label=str(hidden))]
+        self.rows = rows
+        self.index = max(0, min(best_index, len(rows) - 1)) if rows else 0
+        self.kbd_mode = True
+        self.picked = None
+        self.hover = None
+
+    def expand(self):
+        """List every row (the "+ N more" row was picked); the cursor stays
+        on the first newly listed row."""
+        if self.rows is self.all_rows:
+            return
+        cut = len(self.rows) - 1
+        self.rows = self.all_rows
+        self.index = max(0, min(cut, len(self.rows) - 1))
+        self.kbd_mode = True
+        self.picked = None
+
+    def signature(self):
+        return (id(self.rows), self.index, self.kbd_mode, self.hover)
+
+    def current(self):
+        rows = self.rows
+        return rows[self.index] if 0 <= self.index < len(rows) else None