meltygui 0.1.0__py3-none-any.whl

meltygui/core/rendering/mode_defaults.py

@@ -0,0 +1,41 @@
+import sys
+
+
+class ModeDefaults:
+
+    default_mode_from_type = {}
+    # (module name, class name) -> mode, for classes in heavy-weight modules (torch) that we
+    # don't want to import at startup. Resolved to default_mode_from_type once the module loads.
+    _pending = {}
+
+
+def set_default_mode(for_type, mode):
+    ModeDefaults.default_mode_from_type[for_type] = mode
+
+
+def set_default_mode_lazy(module, class_name, mode):
+    mod = sys.modules.get(module)
+    if mod is not None:
+        set_default_mode(getattr(mod, class_name), mode)
+    else:
+        ModeDefaults._pending[(module, class_name)] = mode
+
+
+def _resolve_pending():
+    for (module, class_name), mode in list(ModeDefaults._pending.items()):
+        mod = sys.modules.get(module)
+        if mod is not None:
+            set_default_mode(getattr(mod, class_name), mode)
+            del ModeDefaults._pending[(module, class_name)]
+
+
+def default_mode_for(for_type, default=None):
+    if ModeDefaults._pending:
+        _resolve_pending()
+    return ModeDefaults.default_mode_from_type.get(for_type, default)
+
+
+def register_defaults():
+    from meltygui.core.rendering.modes import Modes
+
+    set_default_mode_lazy('torch', 'Tensor', Modes.FILE_TREE)

meltygui/core/rendering/modes.py

@@ -0,0 +1,136 @@
+"""Symbol access to Mode members without importing core.mode.
+
+`Modes.WINDOW` hands back a deferred handle that resolves to the real Mode.WINDOW
+on first USE — never at attribute access. So storing a mode in a decorator, e.g.
+`@window(mode=Modes.WINDOW_AUTO_FIT)`, never imports core.mode and never trips the
+mode <-> render_dispatch import cycle.
+
+This module imports NOTHING at top level, so it can be imported literally
+anywhere. The single import (core.mode) is deferred to handle resolution, by
+which point core.mode is fully loaded.
+
+The members are generated by CodeGenerator.update_modes().
+"""
+
+
+class _LazyMode:
+    """Deferred, delegating stand-in for a Mode member.
+
+    Resolution (importing core.mode) happens on first USE, not on attribute
+    access — so referencing Modes.X in a decorator stores this handle without
+    importing anything. Once resolved it forwards equality, hashing, str, and
+    attribute/method access (.get_config_for, .name, .value, ...) to the real
+    member. Mode is used by value, never via isinstance, so this stands in for
+    the enum member transparently.
+    """
+
+    __slots__ = ("_name", "_member")
+
+    def __init__(self, name):
+        self._name = name
+        self._member = None
+
+    def _resolve(self):
+        if self._member is None:
+            from meltygui.core.rendering.mode import Mode
+            self._member = Mode[self._name]
+        return self._member
+
+    @property
+    def __class__(self):
+        # Return the resolved Mode's class so `mode.__class__` (and
+        # isinstance(mode, Mode)) see the real enum class, not this stand-in.
+        # This forces resolution (the core.mode import), which is fine on USE -
+        # referencing Modes.X in a decorator otherwise just hands back the
+        # unresolved handle. type(handle) is unaffected and still returns
+        # _LazyMode, so copy/pickle dispatch (which uses type()) is unchanged.
+        return type(self._resolve())
+
+    def __getattr__(self, item):
+        # _name/_member are slots (found normally). Forward real attributes to
+        # the resolved member, but never dunders - copy/pickle probes
+        # (__deepcopy__, __reduce__, ...) must fall through to default handling
+        # rather than triggering resolution (and the core.mode import) early.
+        if item.startswith("__") and item.endswith("__"):
+            raise AttributeError(item)
+        return getattr(self._resolve(), item)
+
+    def __reduce__(self):
+        # Default pickling is broken here BY the lying __class__ property:
+        # object.__reduce_ex__ returns __newobj__(type(self), ...) but pickle's
+        # sanity check compares that against self.__class__ - the resolved
+        # Mode enum class - and raises "args[0] from __newobj__ args has the
+        # wrong class". Every parse holding a mode= reference was therefore
+        # unpicklable, which silently disabled the cst-dump cache for those
+        # files (a multi-second cold parse per session - voxel_view,
+        # new_converters, live_view_views, ...). Reduce BY NAME to a fresh
+        # unresolved handle; resolution happens on first use in the loading
+        # file's module world. Also unbreaks copy.deepcopy (same machinery).
+        return (_LazyMode, (self._name,))
+
+    def __eq__(self, other):
+        if isinstance(other, _LazyMode):
+            other = other._resolve()
+        return self._resolve() == other
+
+    def __hash__(self):
+        return hash(self._resolve())
+
+    def __str__(self):
+        return str(self._resolve())
+
+    def __repr__(self):
+        if self._member is not None:
+            return repr(self._member)
+        return f"_LazyMode({self._name!r})"
+
+
+class _Modes:
+    """`Modes.WINDOW` -> a deferred handle to Mode.WINDOW, no import required.
+
+    The members below are generated by CodeGenerator (one _LazyMode per Mode
+    member) so IDEs autocomplete Modes.<name>. __getattr__ is the fallback for
+    any member added since the last regeneration. Regenerate via
+    CodeGenerator.update_modes().
+    """
+    CODE = _LazyMode("CODE")
+    CODE_INNER_TEXT = _LazyMode("CODE_INNER_TEXT")
+    CODE_INNER_UI = _LazyMode("CODE_INNER_UI")
+    CODE_PLAIN_TEXT = _LazyMode("CODE_PLAIN_TEXT")
+    CODE_UI = _LazyMode("CODE_UI")
+    DROPDOWN_WINDOW = _LazyMode("DROPDOWN_WINDOW")
+    FILE_META = _LazyMode("FILE_META")
+    FILE_TREE = _LazyMode("FILE_TREE")
+    FLOATING = _LazyMode("FLOATING")
+    MODE_WINDOW = _LazyMode("MODE_WINDOW")
+    RUNNING = _LazyMode("RUNNING")
+    SORT = _LazyMode("SORT")
+    TEXT = _LazyMode("TEXT")
+    WINDOW = _LazyMode("WINDOW")
+    WINDOW_AUTO_FIT = _LazyMode("WINDOW_AUTO_FIT")
+    WINDOW_RESIZABLE = _LazyMode("WINDOW_RESIZABLE")
+    WINDOW_CLEAN = _LazyMode("WINDOW_CLEAN")
+    WINDOW_MANAGER_SORTED = _LazyMode("WINDOW_MANAGER_SORTED")
+    WINDOW_NO_HEADER = _LazyMode("WINDOW_NO_HEADER")
+    code_plain_text_auto_load = _LazyMode("code_plain_text_auto_load")
+    code_plain_text_params = _LazyMode("code_plain_text_params")
+    code_ui_auto_load = _LazyMode("code_ui_auto_load")
+    code_ui_params = _LazyMode("code_ui_params")
+    draw_text_funcs = _LazyMode("draw_text_funcs")
+
+    def __getattr__(self, name):
+        # Dunders must NOT fabricate a handle. No Mode member is a dunder, and a
+        # _LazyMode("__wrapped__") detonates the moment anything probes its
+        # __class__ (-> Mode["__wrapped__"] -> KeyError) - which is exactly what
+        # inspect.signature(Modes) does (it probes __wrapped__) when the symbol
+        # index walks this object. Mirror _LazyMode.__getattr__'s own guard so
+        # copy/pickle/unwrap probes fall through to normal AttributeError.
+        if name.startswith("__") and name.endswith("__"):
+            raise AttributeError(name)
+        return _LazyMode(name)
+
+
+# Reference Mode members by symbol without importing core.mode:
+#     from meltygui.core.rendering.modes import Modes
+#     @window(mode=Modes.WINDOW_AUTO_FIT)
+Modes = _Modes()