meltygui 0.1.0__py3-none-any.whl

meltygui/model/file_model.py

@@ -0,0 +1,289 @@
+"""File-tree I/O and metadata adaptation for mutable dictionary values.
+
+These operations do not own windows, pollers, or render state. The core host
+coordinates when disk snapshots and edits pass through them.
+"""
+import os
+import shutil
+from pathlib import Path
+
+from meltygui.core.conversion.bubbling import install_bubbling
+
+def _scan(folder):
+    """Disk → the held shape: {name: Path} for files, {name: {…}} for dirs."""
+    out = {}
+    try:
+        children = sorted(folder.iterdir())
+    except OSError:
+        return out
+    for p in children:
+        if p.name.startswith(".") or p.name == "__pycache__":
+            continue
+        out[p.name] = _scan(p) if p.is_dir() else p
+    return out
+
+
+
+def _create(path, value, pending):
+    """A key the user ADDED → put it on disk. A held dict → mkdir (its children
+    create themselves from the same plan); a held str → a file with those
+    contents; a held Path that still exists elsewhere → a MOVE (a dragged or
+    renamed key is the old Path re-appearing under a new name). A STALE held
+    Path (its file already gone) pairs by basename to a pending delete — the
+    two halves of a move whose delete side was planned first (e.g. undoing a
+    cross-folder drag re-inserts the OLD Path while the file sits at the NEW
+    one) — and moves that file instead of writing an empty husk."""
+    try:
+        if isinstance(value, dict):
+            path.mkdir(exist_ok=True)
+            return
+        if isinstance(value, Path):
+            if value.exists() and value != path:
+                value.replace(path)        # rename() refuses an existing target on Windows
+                pending.discard(value)
+                return
+            if not path.exists():
+                # value == path covers undo: the OLD Path re-inserted at its
+                # old home while the file sits at the move's target.
+                twin = next((p for p in sorted(pending)
+                             if p.name == value.name and p.is_file()), None)
+                if twin is not None:
+                    twin.replace(path)
+                    pending.discard(twin)
+                    return
+        if not path.exists():
+            path.write_text(value if isinstance(value, str) else "")
+    except OSError:
+        pass
+
+
+
+def _delete(path):
+    """A key the user DELETED → remove from disk (rmtree for a folder).
+    Toggles.FileSafety.block_file_delete gates ALL disk deletes (read live);
+    the poller re-discovers the surviving file and restores its key."""
+    from meltygui.core.runtime.toggles import Toggles
+    if Toggles.FileSafety.block_file_delete:
+        print(f"[folder_files] delete blocked (Toggles.FileSafety.block_file_delete): {path}")
+        return
+    try:
+        shutil.rmtree(path) if path.is_dir() else path.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+
+
+def _reconcile(store, disk, folder, seen):
+    """Mirror `store` (the held tree) ⇄ `disk` (the poller's snapshot of
+    `folder`), in place, in two phases. Phase 1 (_collect) walks the whole
+    tree gathering creates and deletes, stamping every planned effect straight
+    into `disk` so the snapshot never lags our own writes — the poller only
+    ever reports EXTERNAL changes. Phase 2 executes EVERY create before ANY
+    delete, tree-wide: a file dragged between folders is renamed (a MOVE)
+    before the old key's delete fires no matter which folder the walk visits
+    first. (The old per-folder ordering destroyed the file's content whenever
+    the source folder reconciled before the target.) A delete consumed by a
+    move pairing is skipped; the rest run last, so a moved folder's old
+    skeleton is removed only after its children have been renamed out."""
+    creates, deletes = [], []
+    _collect(store, disk, folder, seen, creates, deletes)
+    pending = set(deletes)
+    for path, value in creates:
+        _create(path, value, pending)
+    for path in deletes:
+        if path in pending:
+            _delete(path)
+
+
+
+def _collect(store, disk, folder, seen, creates, deletes):
+    """Phase 1 of _reconcile: the recursive walk. A path the store has never
+    SEEN is disk's to give (new on disk → hold it); a path it HAS seen is the
+    user's to take away (key deleted → plan a delete, key added → plan a
+    create). Store/disk/seen bookkeeping happens here — only the disk side
+    effects are deferred to the plan."""
+    for name, value in list(store.items()):
+        if name == "__overrides__":                                 # view metadata, not a file
+            continue
+        if name not in disk and (folder / name) not in seen:        # user added
+            creates.append((folder / name, value))
+            disk[name] = {} if isinstance(value, dict) else folder / name
+            if not isinstance(value, dict):
+                store[name] = disk[name]
+    for name in sorted(set(disk) | set(store)):
+        if name == "__overrides__":
+            continue
+        path = folder / name
+        if name not in store:
+            if path in seen:                                        # user deleted
+                deletes.append(path)
+                disk.pop(name)
+                seen.discard(path)
+                continue
+            store[name] = {} if isinstance(disk[name], dict) else disk[name]   # new on disk
+        elif name not in disk:                                      # vanished from disk
+            store.pop(name)
+            seen.discard(path)
+            continue
+        seen.add(path)
+        if isinstance(store[name], dict):
+            sub = disk[name] if isinstance(disk[name], dict) else {}
+            _collect(store[name], sub, path, seen, creates, deletes)
+
+
+
+def _file_meta(root=None):
+    """The shared path→params store (file_meta.file_meta_store()) — what
+    AppModel.file_meta_collection.file_meta is too. `root` is accepted for
+    the on_load callers and ignored: the store exists before any model."""
+    from meltygui.models.file_meta import file_meta_store
+    return file_meta_store()
+
+
+
+def _apply_meta(tree, folder, meta):
+    """Meta → tree, recursively: stamp __overrides__ entries and sort keys by
+    stored `order`. All writes are inbound state, not user edits — dunder-key
+    stores are raw (no dirty mark) and reorders use raw dict ops — so applying
+    never dirties the host or triggers a save. Returns True if anything
+    changed (caller invalidates the subtree so cached rows repaint)."""
+    changed = False
+    names = [n for n in tree if n != "__overrides__"]
+    desired, orders = {}, {}
+    for n in names:
+        entry = meta.get(str(folder / n))
+        if not isinstance(entry, dict):
+            continue
+        params = {k: v for k, v in entry.items()
+                  if k not in ("order", "project", "environment") and not (isinstance(k, str) and k.startswith("__"))
+                  # unpainted (alpha-0) tint: no override, the row keeps its own
+                  and not (k == "tint" and isinstance(v, (tuple, list))
+                           and len(v) >= 4 and not v[3])}
+        if params:
+            desired[f"__{n}__"] = params
+        if isinstance(entry.get("order"), (int, float)):
+            orders[n] = entry["order"]
+    current = tree.get("__overrides__")
+    if desired:
+        if current != desired:
+            # Wrap entries in the host's bubbling for the raw dunder store,
+            # or later UI edits to an existing entry would show but not save
+            # (see _LazyOverrideEntry's docstring).
+            broot = getattr(tree, "_bubble_root", None)
+            if broot is not None:
+                desired = install_bubbling(desired, broot)
+            tree["__overrides__"] = desired
+            changed = True
+    elif isinstance(current, dict) and current:
+        dict.pop(tree, "__overrides__", None)
+        changed = True
+    if orders:
+        want = sorted(names, key=lambda n: (orders.get(n, float("inf")), n))
+        if names != want:
+            for n in want:
+                dict.__setitem__(tree, n, dict.pop(tree, n))
+            changed = True
+    for n in names:
+        child = tree.get(n)
+        if isinstance(child, dict):
+            changed |= _apply_meta(child, folder / n, meta)
+    return changed
+
+
+
+def _collect_meta(tree, folder, meta):
+    """Tree → meta, recursively: read each child's __overrides__ params back
+    into the persisted store, and capture drag reordering as `order` stamps.
+    Order is stamped only once a folder's key order diverges from the natural
+    sorted order (or was stamped before) — an untouched folder saves nothing."""
+    names = [n for n in tree if n != "__overrides__"]
+    ovs = tree.get("__overrides__")
+    ovs = ovs if isinstance(ovs, dict) else {}
+    stamp_order = (names != sorted(names)
+                   or any(isinstance(meta.get(str(folder / n)), dict)
+                          and "order" in meta[str(folder / n)] for n in names))
+    for i, n in enumerate(names):
+        path = str(folder / n)
+        entry_src = ovs.get(f"__{n}__")
+        entry = {k: v for k, v in entry_src.items()
+                 if not (isinstance(k, str) and k.startswith("__"))} \
+            if isinstance(entry_src, dict) else {}
+        old = meta.get(path)
+        if stamp_order:
+            entry["order"] = i
+        elif isinstance(old, dict) and "order" in old:
+            entry["order"] = old["order"]
+        if entry:
+            if old != entry:
+                from meltygui.models.file_meta import FileMeta
+                meta[path] = FileMeta(entry)
+        elif old is not None:
+            meta.pop(path, None)
+        child = tree.get(n)
+        if isinstance(child, dict):
+            _collect_meta(child, folder / n, meta)
+
+
+def initialize_file_metadata(vis, root):
+    skip_suffixes = {".pyc"}
+    from meltygui.models.file_meta import FileMeta
+    from meltygui.core.runtime.toggles import Toggles
+    meta = _file_meta(root)
+    if meta is None:
+        return
+    # Upgrade entries deserialized as plain dicts (older saves / from_dict)
+    # to FileMeta, keeping their stored values.
+    # Retroactive (09-02): stored tints that were never a user's pick - the
+    # old bluish-grey class default, the tab tint's fallback colour (which got
+    # written back onto 184 files), or an alpha-0 default — are dropped, so
+    # those files read as unpainted (FileMeta.tint, black background).
+    unpainted = {tuple(round(c, 3) for c in FileMeta._LEGACY_DEFAULT_TINT[:3]),
+                 tuple(round(c, 3) for c in Toggles.CodeEditor.tab_tint_fallback[:3])}
+    for key, entry in list(meta.items()):
+        if isinstance(entry, dict) and not isinstance(entry, FileMeta):
+            meta[key] = FileMeta(entry)
+        stored = dict.get(meta[key], "tint") if isinstance(meta[key], dict) else None
+        if stored is None:
+            continue
+        if (FileMeta.painted_tint({"tint": stored}) is None
+                or tuple(round(c, 3) for c in stored[:3]) in unpainted):
+            dict.pop(meta[key], "tint", None)
+            meta.touch(key)      # raw dict op: tell the shared store
+    from meltygui.core.runtime.paths import PACKAGE_ROOT
+    module_root = PACKAGE_ROOT   # .../src
+    for p in module_root.rglob("*"):
+        rel = p.relative_to(module_root).parts
+        if any(part == "__pycache__" or part.startswith(".") for part in rel):
+            continue
+        if p.suffix in skip_suffixes:
+            continue
+        meta.setdefault(str(p), FileMeta())
+
+
+
+def list_directory(directory, show_hidden=False):
+    """The rows of `directory`: [(Path, is_dir)] — folders first, then files,
+    each case-insensitive by name. An unreadable directory lists empty."""
+    try:
+        entries = list(os.scandir(directory))
+    except OSError:
+        return []
+    folders, files = [], []
+    for entry in entries:
+        if not show_hidden and entry.name.startswith("."):
+            continue
+        try:
+            is_dir = entry.is_dir()
+        except OSError:
+            is_dir = False
+        (folders if is_dir else files).append(entry.name)
+    key = str.casefold
+    return ([(Path(directory) / n, True) for n in sorted(folders, key=key)]
+            + [(Path(directory) / n, False) for n in sorted(files, key=key)])
+
+
+def _dir_mtime_ns(directory):
+    try:
+        return os.stat(directory).st_mtime_ns
+    except OSError:
+        return -1

meltygui/model/format_model.py

@@ -0,0 +1,390 @@
+import torch
+
+
+import os
+import pwd
+import subprocess
+import getpass
+
+
+def format_name(self, input_str):
+    """
+    Convert various string formats to properly capitalized space-separated string.
+    Examples:
+        test_string -> Test String
+        testString -> Test String
+        TestString -> Test String
+        test-string -> Test String
+    """
+    # First replace any hyphens with underscores for consistent handling
+    input_str = input_str.replace('-', '_')
+
+    # Split on underscores if they exist
+    if '_' in input_str:
+        words = input_str.split('_')
+    else:
+        # Handle camelCase by adding space before capital letters
+        words = []
+        current_word = input_str[0]
+        for char in input_str[1:]:
+            if char.isupper():
+                words.append(current_word)
+                current_word = char
+            else:
+                current_word += char
+        words.append(current_word)
+
+    # Capitalize each word and join with spaces
+    return ' '.join(word.capitalize() for word in words)
+
+def create_models_folder(password_callback=None, subfolder="latent-descent"):
+    """
+    Creates a folder at /models and a subfolder inside it, both owned by the current user in Linux.
+
+    Args:
+        password_callback (callable, optional): A function that returns the sudo password.
+            If None, will use getpass to prompt the user.
+        subfolder (str, optional): Name of the subfolder to create inside /models.
+            Defaults to "sub".
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    # Check if both directories already exist
+    if os.path.exists('/models') and os.path.exists(f'/models/{subfolder}'):
+        return True
+
+    try:
+        # Get current username
+        current_user = pwd.getpwuid(os.getuid()).pw_name
+
+        # Get password using the callback or default to getpass
+        if password_callback is None:
+            password = getpass.getpass("Enter sudo password: ")
+        else:
+            password = password_callback()
+
+        # Create the commands to run
+        commands = [
+            ["mkdir", "-p", f"/models/{subfolder}"],  # -p will create parent dir if needed
+            ["chown", f"{current_user}:{current_user}", "/models"],
+            ["chown", f"{current_user}:{current_user}", f"/models/{subfolder}"],
+            ["chmod", "755", "/models"],
+            ["chmod", "755", f"/models/{subfolder}"]
+        ]
+
+        # Run each command with sudo using the provided password
+        for cmd in commands:
+            process = subprocess.Popen(
+                ["sudo", "-S"] + cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True
+            )
+            stdout, stderr = process.communicate(input=password + "\n")
+
+            if process.returncode != 0:
+                print(f"Command failed: sudo {' '.join(cmd)}")
+                print(f"Error: {stderr}")
+                return False
+
+        print(f"Successfully created /models directory and /{subfolder} subdirectory owned by {current_user}")
+        return True
+
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        return False
+
+def print_ascii_tensor(tensors, border=True, indices=None, spacing=2, names=None):
+    """
+    Prints an ASCII representation of one or more PyTorch tensors horizontally.
+    - Zeros are replaced with '#' symbols
+    - Single-digit numbers are shown as is
+    - Multi-digit positive numbers are shown as '+'
+    - Multi-digit negative numbers are shown as '-'
+
+    For tensors with more than 2 dimensions, this function will use the last two dimensions
+    by default, or you can specify which indices to use for higher dimensions.
+
+    Args:
+        tensors (torch.Tensor or list): A PyTorch tensor or list of tensors
+        border (bool): Whether to add an ASCII border around each tensor (default: True)
+        indices (tuple or None): Specific indices to use for dimensions beyond the last two.
+                               For a 4D tensor, this would be a tuple of 2 indices.
+        spacing (int): Number of spaces between tensors (default: 2)
+        names (list or None): Optional list of names for each tensor. If provided, must match
+                            the number of tensors. Names will be displayed above each tensor.
+
+    Example:
+        >>> x = torch.tensor([[1, 0, 0], [1, 1, 0], [1, 1, 1]])
+        >>> y = torch.tensor([[0, 0, 2], [0, 3, 2], [4, 3, 2]])
+        >>> print_ascii_tensor([x, y], names=["Identity", "Values"])
+        Identity   Values
+        +-----+    +-----+
+        | 1 # # |  | # # 2 |
+        | 1 1 # |  | # 3 2 |
+        | 1 1 1 |  | 4 3 2 |
+        +-----+    +-----+
+    """
+    # Convert single tensor to list for uniform processing
+    if isinstance(tensors, torch.Tensor):
+        tensors = [tensors]
+
+    # Validate names if provided
+    if names is not None:
+        if len(names) != len(tensors):
+            raise ValueError(f"Number of names ({len(names)}) doesn't match number of tensors ({len(tensors)})")
+
+    # Process each tensor into a list of string rows
+    all_tensor_rows = []
+    max_heights = []
+    tensor_widths = []
+
+    for tensor_idx, tensor in enumerate(tensors):
+        # Handle tensors with more than 2 dimensions
+        tensor_dim = tensor.dim()
+        if tensor_dim > 2:
+            # For tensors with more than 2 dimensions, extract the 2D slice to display
+            if indices is None:
+                # Default: use first indices for all but the last two dimensions
+                slice_indices = tuple([0] * (tensor_dim - 2))
+            else:
+                # Use provided indices
+                if len(indices) != tensor_dim - 2:
+                    raise ValueError(f"Expected {tensor_dim - 2} indices but got {len(indices)}")
+                slice_indices = indices
+
+            # Extract the 2D slice from the tensor
+            tensor_slice = tensor
+            for idx in slice_indices:
+                tensor_slice = tensor_slice[idx]
+
+            tensor = tensor_slice
+
+        # Ensure the tensor is 2D at this point
+        if tensor.dim() != 2:
+            raise ValueError("Each tensor must have at least 2 dimensions")
+
+        # Convert tensor to CPU and get its values as a numpy array
+        tensor_np = tensor.cpu().numpy()
+
+        # Convert tensor to string representation
+        rows = []
+        max_width = 0
+
+        for row in tensor_np:
+            row_str = ""
+            for val in row:
+                if val == 0:
+                    row_str += "0 "
+                else:
+                    # Convert to integer if it's a whole number
+                    if float(val).is_integer():
+                        val = int(val)
+
+                    # Display single-digit numbers as is, use symbols for multi-digit numbers
+                    if -9 <= val <= 9:
+                        row_str += f"{val} "
+                    elif val > 0:
+                        row_str += "+ "
+                    else:  # val < 0
+                        row_str += "- "
+
+            rows.append(row_str.rstrip())  # Remove trailing space
+            max_width = max(max_width, len(row_str.rstrip()))
+
+        # Add border if needed
+        tensor_rows = []
+        if border:
+            # Create top border
+            border_line = "+" + "-" * (max_width + 2) + "+"
+            tensor_rows.append(border_line)
+
+            # Add each row with side borders
+            for row in rows:
+                # Calculate padding to ensure the right border aligns perfectly
+                padding = max_width - len(row)
+                tensor_rows.append(f"| {row}{' ' * padding} |")
+
+            # Create bottom border
+            tensor_rows.append(border_line)
+        else:
+            # Use rows without border
+            tensor_rows = rows
+
+        all_tensor_rows.append(tensor_rows)
+        max_heights.append(len(tensor_rows))
+
+        # Record width of this tensor's rows
+        if len(tensor_rows) > 0:
+            tensor_widths.append(len(tensor_rows[0]))
+        else:
+            tensor_widths.append(0)
+
+    # Print tensor names if provided
+    if names is not None:
+        name_line = ""
+        for tensor_idx, name in enumerate(names):
+            # Center name over tensor width
+            tensor_width = tensor_widths[tensor_idx]
+
+            # If name is longer than tensor, truncate or allow overflow
+            if len(name) > tensor_width:
+                # Let's allow overflow for readability
+                centered_name = name
+            else:
+                # Center the name
+                padding = (tensor_width - len(name)) // 2
+                centered_name = " " * padding + name
+
+            name_line += centered_name
+
+            # Add spacing between tensors (except after the last one)
+            if tensor_idx < len(tensors) - 1:
+                name_line += " " * spacing
+
+        print(name_line)
+
+    # Find the maximum height across all tensors
+    max_height = max(max_heights)
+
+    # Print all tensors horizontally
+    for row_idx in range(max_height):
+        row_str = ""
+        for tensor_idx, tensor_rows in enumerate(all_tensor_rows):
+            # If this tensor has fewer rows than the max height, print empty space
+            if row_idx < len(tensor_rows):
+                row_str += tensor_rows[row_idx]
+            else:
+                # Add empty space for the width of this tensor's representation
+                if len(tensor_rows) > 0:  # Make sure tensor has at least one row
+                    row_str += " " * len(tensor_rows[0])
+
+            # Add spacing between tensors (except after the last one)
+            if tensor_idx < len(all_tensor_rows) - 1:
+                row_str += " " * spacing
+
+        print(row_str)
+    print("\n")
+
+def split_string_by_token(tokenizer, text):
+        if tokenizer is None:
+            return text
+
+        encoding = tokenizer(text, return_tensors="pt", return_attention_mask=True,
+                             add_special_tokens=False)
+        input_ids = encoding['input_ids']
+        # iterate over input ids
+        sequence_length = input_ids.shape[1]
+        batch_size = input_ids.shape[0]
+        batches = []
+        for b in range(batch_size):
+            decoded_tokens = []
+            for s in range(sequence_length):
+                token = input_ids[b, s]
+                token_text = tokenizer.decode(token)
+                decoded_tokens.append(token_text)
+            batches.append(decoded_tokens)
+        return batches
+
+
+def format_time(seconds):
+    """
+    Convert seconds to a human-readable time string with associated color.
+
+    Args:
+        seconds (float): Time in seconds
+
+    Returns:
+        tuple: (formatted_time_string, color_tuple)
+              where color_tuple is (r, g, b) values from 0-1
+    """
+    # Handle negative time
+    if seconds is None:
+        return "Unknown time", (1.0, 0.0, 0.0)
+
+    if seconds < 0:
+        time_str, color = format_time(-seconds)
+        return f"-{time_str}", color
+
+    # Very small time periods - golden yellow (1.0, 0.84, 0)
+    golden_yellow = (1.0, 0.84, 0.0)
+    if seconds < 1:
+        return f"0 seconds", golden_yellow
+
+    # Seconds - golden yellow (1.0, 0.84, 0)
+    if seconds < 60:
+        return f"{seconds:.0f} seconds", golden_yellow
+
+    # Minutes - warm red (0.86, 0.24, 0.2)
+    warm_red = (0.96, 0.44, 0.4)
+    minutes = seconds / 60
+    if minutes < 60:
+        return f"{minutes:.1f} minutes", warm_red
+
+    # Hours - greenish (0.29, 0.71, 0.31)
+    greenish = (0.29, 0.71, 0.31)
+    hours = minutes / 60
+    if hours < 24:
+        return f"{hours:.1f} hours", greenish
+
+    # Days - greenish (0.29, 0.71, 0.31)
+    days = hours / 24
+    if days < 7:
+        return f"{days:.1f} days", greenish
+
+    # Weeks - greenish (0.29, 0.71, 0.31)
+    weeks = days / 7
+    if weeks < 4.35:  # Approximate weeks in a month
+        return f"{weeks:.1f} weeks", greenish
+
+    # Months - greenish (0.29, 0.71, 0.31)
+    months = days / 30.44  # Average days in a month
+    if months < 12:
+        return f"{months:.1f} months", greenish
+
+    # Years - yellow orange (0.94, 0.59, 0.2)
+    yellow_orange = (0.94, 0.59, 0.2)
+    years = days / 365.25
+    if years < 10:
+        return f"{years:.1f} years", yellow_orange
+
+    # Decades - dark bluish grey (0.27, 0.35, 0.43)
+    dark_bluish_grey = (0.27, 0.35, 0.43)
+    if years < 100:
+        return f"{years:.1f} years", dark_bluish_grey
+
+    if years < 1_000:
+        return f"{years:.1f} years", dark_bluish_grey
+
+    if years < 1_000_000:
+        return f"{years / 1_000:.1f} thousand years", dark_bluish_grey
+
+    # Millions of years - dark red (0.55, 0.12, 0.12)
+    dark_red = (0.55, 0.12, 0.12)
+    if years < 1_000_000_000:
+        return f"{years / 1_000_000:.1f} million years", dark_red
+
+    # Billions of years and beyond - blue (0.12, 0.31, 0.71)
+    blue = (0.12, 0.31, 0.71)
+
+    # Use descriptive strings instead of numerical values for billion+ years
+    if years < 4.5e9:  # Age of Earth ~4.5 billion years
+        return "Age of the Earth", blue
+
+    if years < 5e9:  # Approximate time until Sun begins to expand significantly
+        return "Time until the Sun begins expanding", blue
+
+    if years < 7.6e9:  # Time until Sun engulfs Earth's orbit
+        return "Time until the Sun engulfs Earth", blue
+
+    if years < 1e14:  # Time until all stars burn out
+        return "Era of stellar extinction", blue
+
+    if years < 1e40:  # Deep time
+        return "Approaching heat death of the universe", blue
+
+    return "Beyond heat death of the universe", blue
+
+