meltygui 0.1.0__py3-none-any.whl

meltygui/core/runtime/lifecycle.py

@@ -0,0 +1,21 @@
+"""Session-lifetime checks for long-running threads.
+
+A studio "restart" is IN-PROCESS: model_server purges every `src.*` entry from
+sys.modules and re-imports, so a daemon poller started by the previous session
+keeps running against its OLD module globals — and pins that whole session
+(old Melty → draw_states → code hosts → parsed cst dicts) for the life of the
+process, while still doing its polling. Found via the gc boot profile: ~1M
+retained objects per restart after the atexit/gc.callbacks roots were fixed.
+
+`module_is_live(globals())` is the exit test for such loops: it is True while
+the caller's module dict is the one currently registered under its name.
+A hotswap re-execs INTO the same dict, so the check survives hotswap; a
+restart binds a new module object, so every old-session loop sees False on
+its next iteration and returns.
+"""
+import sys
+
+
+def module_is_live(module_globals):
+    mod = sys.modules.get(module_globals.get("__name__"))
+    return mod is not None and getattr(mod, "__dict__", None) is module_globals

meltygui/core/runtime/paths.py

@@ -0,0 +1,27 @@
+"""Locations shared by the installed framework and its host application."""
+from pathlib import Path
+import os
+import sys
+import tempfile
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[2]
+
+
+def application_root():
+    """Nearest project marker above the entry point, or its containing folder."""
+    entry = getattr(sys.modules.get('__main__'), '__file__', None)
+    start = Path(entry).resolve().parent if entry else Path.cwd()
+    for folder in (start, *start.parents):
+        if any((folder / marker).exists() for marker in ('.git', 'pyproject.toml', 'setup.py', 'setup.cfg')):
+            return folder
+    return start
+
+
+def cache_root():
+    return Path(os.environ.get('XDG_CACHE_HOME') or Path.home() / '.cache') / 'meltygui'
+
+
+def debug_log_path(name):
+    """Where a diagnostics trail (`tail -f` while reproducing) is written: the
+    system temp folder, /tmp on Linux and %TEMP% on Windows."""
+    return os.path.join(tempfile.gettempdir(), name)

meltygui/core/runtime/settings.py

@@ -0,0 +1,14 @@
+"""Runtime settings access independent of any settings-search UI."""
+def toggle_setting(path):
+    from meltygui.core.runtime.extensions import get
+    provider = get('toggle_setting')
+    if provider is not None:
+        return provider(path)
+    from meltygui.core.runtime.toggles import Toggles
+    owner = Toggles
+    parts = path.split('.')
+    for part in parts[:-1]:
+        owner = getattr(owner, part)
+    value = not getattr(owner, parts[-1])
+    setattr(owner, parts[-1], value)
+    return value

meltygui/core/runtime/singleton.py

@@ -0,0 +1,16 @@
+"""Torch-free ``singleton`` decorator.
+
+Lives in its own module so GUI code (custom_views) can use it without importing
+``src.lsd.train.lsd_utils``, which pulls in torch.optim at load time.
+"""
+
+
+def singleton(cls):
+    instances = {}
+
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance

meltygui/core/runtime/thread_safe_bool.py

@@ -0,0 +1,24 @@
+## Utils
+from asyncio import Lock
+
+
+def clamp(value, min_value, max_value):
+    return max(min(value, max_value), min_value)
+
+
+class ThreadSafeBool:
+    def __init__(self, initial_value=False):
+        self._value = initial_value
+        self._lock = Lock()
+
+    def __bool__(self):
+        with self._lock:
+            return self._value
+
+    def __eq__(self, other):
+        with self._lock:
+            return self._value == other
+
+    def __set__(self, value):
+        with self._lock:
+            self._value = bool(value)

meltygui/core/runtime/thread_signal.py

@@ -0,0 +1,30 @@
+import threading
+
+
+class PauseSignal:
+    def __init__(self):
+        self._event = threading.Event()
+        # Initially clear (not paused) so threads can process
+        self._event.clear()
+
+    def pause(self):
+        """Signal threads to pause processing"""
+        self._event.set()
+
+    def resume(self):
+        """Signal threads to resume processing"""
+        self._event.clear()
+
+    def wait_if_paused(self):
+        """
+        If paused, wait until resumed
+        Otherwise return immediately
+        """
+        self._event.wait()
+        # If we reach here and it's still set, wait again
+        while self._event.is_set():
+            self._event.wait(0.1)  # Small timeout to recheck condition
+
+    def is_paused(self):
+        """Check if processing should be paused"""
+        return self._event.is_set()