meltygui 0.1.0__py3-none-any.whl

meltygui/core/conversion/dict_conversion_util.py

@@ -0,0 +1,177 @@
+import importlib
+import inspect
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Dict, List, Tuple
+
+from meltygui.utils.render_utils import print_stack_trace
+
+def find_repo_root(start_path: Path | str = None) -> Path:
+    # Check if __file is defined
+    if '__file__' in globals():
+        if start_path is None:
+            start_path = Path(os.path.dirname(os.path.abspath(__file__)))
+
+    # If start_path is not provided, use the current working directory
+    if start_path is None:
+        start_path = os.getcwd()
+
+    current = Path(start_path).resolve()
+
+    while current != current.parent:
+        if (current / '.git').exists():
+            return current
+        current = current.parent
+
+    # If we reach here, we didn't find a .git directory, use module path
+    module_path = Path(__file__).resolve().parents[1]
+    print(f"Warning: No .git directory found. Using module path: {module_path}")
+    return module_path.parent if module_path.parent.exists() else module_path
+
+
+def find_nested_classes(parent_class: type, parent_path: str) -> List[Tuple[str, type]]:
+    """
+    Recursively find all nested classes within a class.
+
+    Args:
+        parent_class: The parent class to search in
+        parent_path: The full path of the parent class
+
+    Returns:
+        A list of tuples (full_class_path, class_object) for nested classes
+    """
+    nested_classes = []
+
+    # Check all attributes of the class
+    for name, obj in parent_class.__dict__.items():
+        # Skip special methods, private attributes, and non-classes
+        if name.startswith('__'):
+            continue
+
+        if not isinstance(obj, type):
+            continue
+
+        # Build the path for this nested class
+        class_path = f"{parent_path}.{name}"
+        nested_classes.append((class_path, obj))
+
+        # Recursively find classes nested within this class
+        inner_classes = find_nested_classes(obj, class_path)
+        nested_classes.extend(inner_classes)
+
+    return nested_classes
+
+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
+
+
+@singleton
+class ClassUtility:
+
+    def __init__(self):
+        self.class_names: Optional[Dict[str, str]] = None
+        self.modules_imported = set()
+        self.root = None
+        self.initialized_modules = {}
+        self._module_count = -1
+
+    def initialize_class_names(self, root=None):
+        if self.class_names is not None and self._module_count == len(sys.modules):
+            return
+        self._module_count = len(sys.modules)
+        self.class_names = {}
+        for module_name, module in list(sys.modules.items()):
+            if module is None:
+                continue
+            for name, value in list(vars(module).items()):
+                if isinstance(value, type) and value.__module__ == module_name:
+                    self.class_names.setdefault(name, f"{module_name}.{name}")
+                    for nested_path, nested in find_nested_classes(value, f"{module_name}.{name}"):
+                        self.class_names.setdefault('.'.join(nested_path.split('.')[-2:]), nested_path)
+
+
+    @staticmethod
+    def find_all_classes(root_dir: str, package_name: str = None) -> List[Tuple[str, str]]:
+        """
+        Find all classes in a package directory structure, including nested directories and nested classes.
+
+        Args:
+            root_dir: The root directory to search in
+            package_name: Optional base package name prefix
+
+        Returns:
+            A list of tuples (full_class_path, class_object)
+        """
+        classes = []
+        visited_modules = set()
+
+        # Check if path exists
+        if not os.path.exists(root_dir):
+            root_dir = os.path.abspath(f"./{root_dir}")
+
+        if not os.path.isdir(root_dir):
+            print(f"Error: {root_dir} is not a directory")
+            # Print stack
+            print_stack_trace()
+            return classes
+
+        # Walk through all Python files in the directory structure
+        for dirpath, dirnames, filenames in os.walk(root_dir):
+            # Skip __pycache__ and other hidden directories
+            dirnames[:] = [d for d in dirnames if not d.startswith('__') and not d.startswith('.')]
+
+            # Get the relative path from the root directory
+            rel_path = os.path.relpath(dirpath, root_dir)
+
+            # Convert directory path to module path
+            if rel_path == '.':
+                module_prefix = package_name or os.path.basename(root_dir)
+            else:
+                module_prefix = f"{package_name or os.path.basename(root_dir)}.{rel_path.replace(os.sep, '.')}"
+
+            # Process Python files in this directory
+            for filename in filenames:
+                if filename.endswith('.py') and not filename.startswith('__'):
+                    module_name = f"{module_prefix}.{filename[:-3]}"
+
+                    # Skip already visited modules
+                    if module_name in visited_modules:
+                        continue
+
+                    visited_modules.add(module_name)
+                    if "app_model" in module_name:
+                        pass
+                    try:
+                        # Import the module
+                        module = sys.modules.get(module_name)
+                        # importlib.reload(module)
+
+                        # Find top-level classes in this module and add them
+                        for name, obj in inspect.getmembers(module, inspect.isclass):
+                            # Only include classes defined in this module (not imported)
+                            # Add class
+                            if obj.__module__ == module_name:
+                                class_path = f"{module_name}.{name}"
+                                parts = class_path.split('.')
+                                classes.append((parts[-1], class_path))
+
+                                # Now find nested classes
+                                nested_classes = find_nested_classes(obj, class_path)
+                                if len(nested_classes) > 0:
+                                    for nested_class_path, nested_class in nested_classes:
+                                        nested_parts = nested_class_path.split('.')
+                                        nested_key = f"{nested_parts[-2]}.{nested_parts[-1]}"
+                                        classes.append((nested_key, nested_class_path))
+
+                    except (ImportError, ModuleNotFoundError) as e:
+                        print(f"Error importing {module_name}: {e}")
+
+        return classes

meltygui/core/conversion/dynamic_obj.py

@@ -0,0 +1,89 @@
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.utils.render_utils import LSDView
+
+
+class DynamicObj(DictConversion):
+    """Simplified class that mirrors driver dict keys as attributes in real-time."""
+
+    def __init__(self, driver_dict=None):
+        super().__init__()
+        self.driver = None
+        self._root = None
+        self.not_real = set()
+
+        # Store driver using super().__setattr__ to avoid recursion
+        super().__setattr__('driver', driver_dict if driver_dict is not None else {})
+
+    def __getattr__(self, name):
+        if name == 'driver' or name == '_root':
+            # Return driver or root directly
+            return None
+
+        # Only called when attribute doesn't exist
+        # Check if it's a driver key
+        if self._root is not None:
+            driver = self._root.get(self.driver)
+        else:
+            real_dict = object.__getattribute__(self, '__dict__')
+            if name not in real_dict:
+                # Create the attribute with None value
+                raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+            else:
+                return real_dict[name]
+        # Todo: dynamic add
+        if hasattr(self, 'driver') and name in driver:
+            real_dict = object.__getattribute__(self, '__dict__')
+            if name not in real_dict:
+                # Create the attribute with None value
+                return None
+            else:
+                return real_dict[name]
+
+        # If not in driver, raise AttributeError
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+    # has attrib check
+    def __hasattr__(self, name):
+        return True
+
+    def __getattribute__(self, name):
+        if name == 'driver' or name == '_root':
+            # Return driver or root directly
+            return super().__getattribute__(name)
+
+        # Intercept __dict__ access
+        if self.driver is not None and self._root is not None:
+            driver = self._root.get(self.driver)
+        else:
+            driver = {}
+
+        if name == '__dict__':
+            # Get real dict without recursion
+            real_dict = object.__getattribute__(self, '__dict__')
+
+            for key in driver:
+                if key not in real_dict:
+                    setattr(self, key, None)
+                    self.not_real.add(key)
+
+            to_remove = set()
+            for key in self.not_real:
+                # Indicates that the attribute was removed
+                if key not in driver:
+                    to_remove.add(key)
+
+            for key in to_remove:
+                self.not_real.remove(key)
+                if key in real_dict:
+                    real_dict.pop(key)
+
+        # Only called when attribute doesn't exist
+        # Check if it's a driver key
+
+        # if name != 'driver' and name != '_root' and name in driver:
+        #     # Create the attribute with None value
+        #     setattr(self, name, None)
+        #     return None
+
+        # For everything else, use default behavior
+        return super().__getattribute__(name)

meltygui/core/conversion/graph_compare.py

@@ -0,0 +1,183 @@
+"""
+graph_compare — structural + sharing-topology equality for object graphs.
+
+This is the acceptance oracle for the load/save work: it proves that a
+round-tripped graph reproduces the original. "Reproduces" means three things,
+in increasing strength:
+
+  1. same class at every node,
+  2. same *serialized* public field values (the fields load/save round-trips),
+  3. same SHARING TOPOLOGY — if two paths in graph A reach one shared object,
+     the same two paths in graph B must reach one shared object too (and cycles
+     close at the same place). This is the "object reference tree" property the
+     whole exercise is about; plain field-equality misses it.
+
+It deliberately compares only the fields that load/save is responsible for
+(public, non-excluded, non-underscore) so that dropped transient state
+(_parent weakrefs, GL handles, lambdas) doesn't register as a difference.
+"""
+from enum import Enum
+
+_PRIMITIVE = (int, float, bool, str, bytes, type(None))
+
+
+# Single source of truth: reuse v2's exact suppression set so the oracle can't
+# drift from what's actually serialized (v1). @exclude/__excluded_attrs__ is NOT
+# here (it only gates @live invalidation), so type/name/id is compared.
+from meltygui.core.conversion.load_save_v2 import _suppressed as _v2_suppressed
+
+
+def _public_keys(obj, excluded=()):
+    """The attribute names load/save is responsible for: public, not suppressed.
+    `excluded` mirrors the caller-level drop list passed to v2.dumps, so fields the
+    save deliberately omits aren't flagged as round-trip diffs.
+
+    Iterates the DEFAULT instance's keys, matching v2._save_state's delta encoding
+    (which serializes only fields present on a fresh default). Fields that exist on
+    `obj` but not on the default are runtime-injected and intentionally NOT
+    round-tripped (to_dict drops them too), so they must not register as diffs."""
+    excl = _v2_suppressed(obj, excluded)
+    cls = type(obj)
+    default = getattr(cls, "default_instance", None)
+    src = default if default is not None else obj
+    return sorted(k for k in vars(src) if not k.startswith("_") and k not in excl)
+
+
+class Diff(list):
+    """A list of human-readable difference strings; truthy iff graphs differ."""
+    def report(self, limit=40):
+        if not self:
+            return "graphs are structurally equivalent (incl. sharing topology)"
+        head = self[:limit]
+        extra = f"\n  ... and {len(self) - limit} more" if len(self) > limit else ""
+        return f"{len(self)} difference(s):\n  " + "\n  ".join(head) + extra
+
+
+def compare(a, b, *, ignore=(), excluded=()):
+    """Return a Diff describing how graph ``b`` deviates from graph ``a``.
+
+    ``ignore`` is a set of attribute names skipped everywhere (e.g. {'id'} when
+    ids are intentionally regenerated on load).
+    ``excluded`` is the caller-level field-drop list passed to v2.dumps — those
+    fields aren't serialized, so they're not compared.
+    """
+    diffs = Diff()
+    ignore = set(ignore)
+    excluded = frozenset(excluded)
+
+    # identity maps: object in A -> object in B that it first paired with.
+    # En catch sharing-topology divergence: if A-node X pairs with B-node Y once,
+    # any later encounter of X must again pair with Y (and vice-versa), else the
+    # aliasing/cycle structure differs between the two graphs.
+    a_to_b = {}
+    b_to_a = {}
+
+    def walk(x, y, path):
+        # --- primitives & enums: value equality ---
+        # Compare enums by class QUALNAME + member name (not class identity): a
+        # load/save round-trip can legitimately land an equivalent class object
+        # under a different module identity; what matters is same enum, same member.
+        if isinstance(x, Enum) or isinstance(y, Enum):
+            xt = type(x).__qualname__ if isinstance(x, Enum) else f"<non-enum {type(x).__name__}>"
+            yt = type(y).__qualname__ if isinstance(y, Enum) else f"<non-enum {type(y).__name__}>"
+            if xt != yt or getattr(x, "name", None) != getattr(y, "name", None):
+                diffs.append(f"{path}: enum {xt}.{getattr(x,'name','?')} != {yt}.{getattr(y,'name','?')}")
+            return
+        if isinstance(x, _PRIMITIVE) or isinstance(y, _PRIMITIVE):
+            if type(x) is not type(y) or x != y:
+                diffs.append(f"{path}: {x!r} ({type(x).__name__}) != {y!r} ({type(y).__name__})")
+            return
+
+        # --- sharing topology: enforce for consistent bijection on non-primitives ---
+        xid, yid = id(x), id(y)
+        if xid in a_to_b:
+            if a_to_b[xid] is not y:
+                diffs.append(f"{path}: sharing diverged — A node reused but B node differs "
+                             f"(A first paired at a different B object)")
+            return  # already fully compared on first encounter
+        if yid in b_to_a and b_to_a[yid] is not x:
+            diffs.append(f"{path}: sharing diverged — B node is shared but A node is not")
+            return
+        a_to_b[xid] = y
+        b_to_a[yid] = x
+
+        # --- callables / types: compare by reference identity of name ---
+        if callable(x) or isinstance(x, type):
+            xn = getattr(x, "__qualname__", repr(x))
+            yn = getattr(y, "__qualname__", repr(y))
+            if xn != yn:
+                diffs.append(f"{path}: callable/type {xn} != {yn}")
+            return
+
+        # --- containers ---
+        if isinstance(x, dict) or isinstance(y, dict):
+            if not (isinstance(x, dict) and isinstance(y, dict)):
+                diffs.append(f"{path}: dict vs non-dict ({type(x).__name__}/{type(y).__name__})")
+                return
+            xk, yk = set(x.keys()), set(y.keys())
+            if xk != yk:
+                only_a = sorted(map(repr, xk - yk))[:6]
+                only_b = sorted(map(repr, yk - xk))[:6]
+                diffs.append(f"{path}: dict keys differ  only-A={only_a}  only-B={only_b}")
+            for k in xk & yk:
+                walk(x[k], y[k], f"{path}[{k!r}]")
+            return
+        if isinstance(x, (list, tuple)) or isinstance(y, (list, tuple)):
+            if type(x) is not type(y):
+                diffs.append(f"{path}: seq type {type(x).__name__} != {type(y).__name__}")
+                return
+            if len(x) != len(y):
+                diffs.append(f"{path}: length {len(x)} != {len(y)}")
+            for i in range(min(len(x), len(y))):
+                walk(x[i], y[i], f"{path}[{i}]")
+            return
+        if isinstance(x, (set, frozenset)) or isinstance(y, (set, frozenset)):
+            if x != y:
+                diffs.append(f"{path}: set contents differ")
+            return
+
+        # --- objects by attributes ---
+        if type(x) is not type(y):
+            diffs.append(f"{path}: class {type(x).__name__} != {type(y).__name__}")
+            return
+        if not hasattr(x, "__dict__"):
+            if x != y:
+                diffs.append(f"{path}: {type(x).__name__} {x!r} != {y!r}")
+            return
+        ka = [k for k in _public_keys(x, excluded) if k not in ignore]
+        kb = [k for k in _public_keys(y, excluded) if k not in ignore]
+        if ka != kb:
+            sa, sb = set(ka), set(kb)
+            diffs.append(f"{path} <{type(x).__name__}>: fields differ  "
+                         f"only-A={sorted(sa - sb)}  only-B={sorted(sb - sa)}")
+        for k in ka:
+            if k in ignore or k not in kb:
+                continue
+            walk(getattr(x, k), getattr(y, k), f"{path}.{k}")
+
+    walk(a, b, "root")
+    return diffs
+
+
+def count_nodes(obj):
+    """How many distinct non-primitive objects the graph reaches (sanity sizing)."""
+    seen = set()
+
+    def walk(o):
+        if isinstance(o, _PRIMITIVE) or isinstance(o, Enum):
+            return
+        if id(o) in seen:
+            return
+        seen.add(id(o))
+        if isinstance(o, dict):
+            for v in o.values():
+                walk(v)
+        elif isinstance(o, (list, tuple, set, frozenset)):
+            for v in o:
+                walk(v)
+        elif hasattr(o, "__dict__"):
+            for k in _public_keys(o):
+                walk(getattr(o, k))
+
+    walk(obj)
+    return len(seen)