meltygui 0.1.0__py3-none-any.whl

meltygui/utils/jump_to_code.py

@@ -0,0 +1,344 @@
+import os
+import subprocess
+import inspect
+import ast
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any, Callable, Union
+import importlib
+
+
+def find_function_line(file_path: str, function_name: str) -> Optional[int]:
+    """
+    Find the line number where a function is defined in a Python file.
+
+    Args:
+        file_path: Path to the Python file
+        function_name: Name of the function to find
+
+    Returns:
+        Line number where the function is defined, or None if not found
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        # Parse the AST to find function definitions
+        tree = ast.parse(content)
+
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == function_name:
+                return node.lineno
+
+    except Exception as e:
+        print(f"Error parsing file: {e}")
+
+    return None
+
+
+def find_class_line(file_path: str, class_name: str) -> Optional[int]:
+    """
+    Find the line number where a class is defined in a Python file.
+
+    Args:
+        file_path: Path to the Python file
+        class_name: Name of the class to find
+
+    Returns:
+        Line number where the class is defined, or None if not found
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        # Parse the AST to find class definitions
+        tree = ast.parse(content)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef) and node.name == class_name:
+                return node.lineno
+
+    except Exception as e:
+        print(f"Error parsing file: {e}")
+
+    return None
+
+
+def find_intellij_executable() -> Optional[str]:
+    """
+    Find IntelliJ executable, handling version-specific installations.
+
+    Returns:
+        Path to IntelliJ executable, or None if not found
+    """
+    import glob
+
+    # Common installation patterns
+    search_patterns = []
+
+    if os.name == 'nt':  # Windows
+        search_patterns = [
+            r'C:\Program Files\JetBrains\IntelliJ IDEA*\bin\idea64.exe',
+            r'C:\Program Files (x86)\JetBrains\IntelliJ IDEA*\bin\idea.exe',
+            r'C:\Program Files\JetBrains\IntelliJ IDEA Community Edition*\bin\idea64.exe',
+        ]
+    elif os.name == 'posix':  # Linux/macOS
+        search_patterns = [
+            # Linux patterns
+            '/opt/idea-*/bin/idea.sh',
+            '/opt/intellij-idea-*/bin/idea.sh',
+            '/usr/local/idea-*/bin/idea.sh',
+            '/home/*/idea-*/bin/idea.sh',
+            '/home/*/.local/share/JetBrains/Toolbox/apps/IDEA-U/ch-*/*/bin/idea.sh',
+            '/home/*/.local/share/JetBrains/Toolbox/apps/IDEA-C/ch-*/*/bin/idea.sh',
+            # Snap installations
+            '/snap/intellij-idea-ultimate/current/bin/idea.sh',
+            '/snap/intellij-idea-community/current/bin/idea.sh',
+        ]
+
+        if os.uname().sysname == 'Darwin':  # macOS
+            search_patterns.extend([
+                '/Applications/IntelliJ IDEA.app/Contents/MacOS/idea',
+                '/Applications/IntelliJ IDEA CE.app/Contents/MacOS/idea',
+                '/Users/*/Applications/IntelliJ IDEA.app/Contents/MacOS/idea',
+                '/Applications/JetBrains Toolbox/IntelliJ IDEA.app/Contents/MacOS/idea',
+            ])
+
+    # PATH first: the version the desktop actually uses (`idea.sh`), which
+    # beats guessing among sibling installs (`/opt/idea-*_old` sorts LAST
+    # and won the "newest" pick below).
+    import shutil
+    for name in ('idea.sh', 'idea'):
+        found = shutil.which(name)
+        if found:
+            return found
+
+    # Search for IntelliJ in common locations
+    for pattern in search_patterns:
+        matches = [m for m in glob.glob(pattern) if not m.split('/bin/')[0].endswith('_old')]
+        if matches:
+            # Return the latest version if multiple found
+            return max(matches)
+
+    # Check environment variable
+    intellij_home = os.environ.get('INTELLIJ_HOME')
+    if intellij_home:
+        idea_path = os.path.join(intellij_home, 'bin', 'idea.sh' if os.name == 'posix' else 'idea64.exe')
+        if os.path.exists(idea_path):
+            return idea_path
+
+    return None
+
+
+def open_in_intellij(file_path, line_number=None):
+    # Use absolute path
+
+    idea_path = find_intellij_executable()
+
+    # Check if file exists
+    if not os.path.exists(file_path):
+        print(f"File not found: {file_path}")
+        return
+
+    from meltygui.core.runtime.paths import application_root
+    project_root = str(application_root())
+
+    if line_number:
+        # Open project, then file with line number
+        cmd = [f'{idea_path}', project_root, '--line', str(line_number), file_path]
+    else:
+        cmd = [f'{idea_path}', project_root, file_path]
+
+    if idea_path is None:
+        print("IntelliJ executable not found (set INTELLIJ_HOME)")
+        return
+    # Full-path executable + close_fds=False keeps this on posix_spawn - a
+    # fork() of the studio deadlocks (see CL-MDE.md, "never fork the studio").
+    subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                   close_fds=False)
+
+def build_function_map(module) -> Dict[str, Dict[str, Any]]:
+    """
+    Build a function map from a module with function metadata.
+
+    Args:
+        module: The module to inspect
+
+    Returns:
+        Dictionary mapping function names to their metadata
+    """
+    # Get all functions from the module
+    functions = inspect.getmembers(module, inspect.isfunction)
+
+    # Filter to only functions defined in this module
+    functions = [(name, obj) for name, obj in functions
+                 if obj.__module__ == module.__name__]
+
+    function_map = {}
+
+    for name, func in functions:
+        # Get the source file
+        try:
+            source_file = inspect.getsourcefile(func)
+            source_lines, start_line = inspect.getsourcelines(func)
+
+            function_map[name] = {
+                'function': func,
+                'file': source_file,
+                'line': start_line,
+                'module': module.__name__,
+                'docstring': inspect.getdoc(func),
+                'signature': str(inspect.signature(func))
+            }
+        except Exception as e:
+            print(f"Error processing function {name}: {e}")
+
+    return function_map
+
+
+def build_class_map(module) -> Dict[str, Dict[str, Any]]:
+    """
+    Build a class map from a module with class metadata.
+
+    Args:
+        module: The module to inspect
+
+    Returns:
+        Dictionary mapping class names to their metadata
+    """
+    # Get all classes from the module
+    classes = inspect.getmembers(module, inspect.isclass)
+
+    # Filter to only classes defined in this module
+    classes = [(name, obj) for name, obj in classes
+               if obj.__module__ == module.__name__]
+
+    class_map = {}
+
+    for name, cls in classes:
+        # Get the source file
+        try:
+            source_file = inspect.getsourcefile(cls)
+            source_lines, start_line = inspect.getsourcelines(cls)
+
+            class_map[name] = {
+                'class': cls,
+                'file': source_file,
+                'line': start_line,
+                'module': module.__name__,
+                'docstring': inspect.getdoc(cls),
+                'bases': [base.__name__ for base in cls.__bases__],
+                'methods': [method for method in dir(cls) if not method.startswith('_')]
+            }
+        except Exception as e:
+            print(f"Error processing class {name}: {e}")
+
+    return class_map
+
+
+def build_combined_map(module) -> Dict[str, Dict[str, Any]]:
+    """
+    Build a combined map of functions and classes from a module.
+
+    Args:
+        module: The module to inspect
+
+    Returns:
+        Dictionary mapping names to their metadata (functions and classes)
+    """
+    combined_map = {}
+
+    # Add functions
+    function_map = build_function_map(module)
+    for name, info in function_map.items():
+        info['type'] = 'function'
+        combined_map[name] = info
+
+    # Add classes
+    class_map = build_class_map(module)
+    for name, info in class_map.items():
+        info['type'] = 'class'
+        combined_map[name] = info
+
+    return combined_map
+
+
+def jump_to_function(root, function_name: str) -> bool:
+    """
+    Jump to a function in IntelliJ using the root's jump map.
+
+    Args:
+        root: The root object containing the _jump_to_map
+        function_name: Name of the function to jump to
+
+    Returns:
+        True if successful, False otherwise
+    """
+    a_function_map = root.view_functions._jump_to_map
+    return jump_to_item_by_map(a_function_map, function_name)
+
+
+def jump_to_class(root, class_name: str) -> bool:
+    """
+    Jump to a class in IntelliJ using the root's jump map.
+
+    Args:
+        root: The root object containing the _jump_to_map
+        class_name: Name of the class to jump to
+
+    Returns:
+        True if successful, False otherwise
+    """
+    a_class_map = root.datatypes._jump_to_map
+    return jump_to_item_by_map(a_class_map, class_name)
+
+
+def jump_to_item(root, item_name: str) -> bool:
+    """
+    Jump to a function or class in IntelliJ using the root's jump map.
+
+    Args:
+        root: The root object containing the _jump_to_map
+        item_name: Name of the function or class to jump to
+
+    Returns:
+        True if successful, False otherwise
+    """
+    jump_map = root.view_functions._jump_to_map
+    return jump_to_item_by_map(jump_map, item_name)
+
+
+def jump_to_function_by_map(function_map: Dict[str, Dict[str, Any]], function_name: str) -> bool:
+    """
+    Jump to a function in IntelliJ using the function map.
+    (Deprecated: Use jump_to_item_by_map instead)
+
+    Args:
+        function_map: Dictionary mapping function names to metadata
+        function_name: Name of the function to jump to
+
+    Returns:
+        True if successful, False otherwise
+    """
+    return jump_to_item_by_map(function_map, function_name)
+
+
+def jump_to_item_by_map(item_map: Dict[str, Dict[str, Any]], item_name: str) -> bool:
+    """
+    Jump to a function or class in IntelliJ using the item map.
+
+    Args:
+        item_map: Dictionary mapping item names to metadata
+        item_name: Name of the function or class to jump to
+
+    Returns:
+        True if successful, False otherwise
+    """
+    if item_name not in item_map:
+        return False
+
+    item_info = item_map[item_name]
+    file_path = item_info['file']
+    line_number = item_info['line']
+
+    return open_in_intellij(file_path, line_number=line_number)

meltygui/utils/pkl_inspect.py

@@ -0,0 +1,90 @@
+"""
+pkl_inspect — make a binary load_save_v2 .pkl debuggable.
+
+  python -m meltygui.utils.pkl_inspect [path/to/custom.pkl] [--depth N]
+
+Loads the pkl and prints the object tree with, per field, the SERIALIZED size
+(re-pickling just that subtree) and node count — sorted biggest-first, so you can
+see exactly what dominates the file and spot anything that's growing.
+"""
+import sys
+from enum import Enum
+
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.core.conversion.dict_conversion_util import ClassUtility
+import meltygui.core.conversion.load_save_v2 as v2
+import meltygui.core.conversion.graph_compare as gc
+
+_PRIM = (int, float, bool, str, bytes, type(None))
+
+
+def _size(v):
+    try:
+        return len(v2.dumps(v, excluded=list(v2.STUDIO_SAVE_EXCLUDED)))
+    except Exception:
+        return -1
+
+
+def _children(o):
+    """(label, value) pairs one level down — public fields / dict items / seq items."""
+    if isinstance(o, dict):
+        return [(f"[{k!r}]", val) for k, val in o.items()]
+    if isinstance(o, (list, tuple)):
+        return [(f"[{i}]", val) for i, val in enumerate(o)]
+    if isinstance(o, DictConversion) or hasattr(o, "__dict__"):
+        return [(f".{k}", getattr(o, k, None)) for k in gc._public_keys(o)]
+    return []
+
+
+def _kind(o):
+    if isinstance(o, Enum):
+        return f"{type(o).__name__}.{o.name}"
+    if isinstance(o, _PRIM):
+        return type(o).__name__
+    n = ""
+    if isinstance(o, dict):
+        n = f"({len(o)})"
+    elif isinstance(o, (list, tuple, set)):
+        n = f"({len(o)})"
+    return f"{type(o).__name__}{n}"
+
+
+def dump_tree(o, depth=2, label="root", indent=0, min_kb=0.0):
+    sz = _size(o)
+    nodes = gc.count_nodes(o) if not isinstance(o, _PRIM) else 0
+    pad = "  " * indent
+    szs = f"{sz/1024:8.1f} KB" if sz >= 0 else "   (n/a)"
+    print(f"{szs}  {nodes:>7} nodes  {pad}{label}: {_kind(o)}")
+    if indent >= depth or isinstance(o, _PRIM) or isinstance(o, Enum):
+        return
+    kids = _children(o)
+    # sort children by serialized size, biggest first; skip tiny ones past depth 0
+    sized = sorted(((_size(v), lbl, v) for lbl, v in kids), key=lambda t: -t[0])
+    for s, lbl, v in sized:
+        if s / 1024.0 < min_kb:
+            continue
+        dump_tree(v, depth, lbl, indent + 1, min_kb)
+
+
+def main():
+    args = [a for a in sys.argv[1:] if not a.startswith("--")]
+    if not args:
+        raise SystemExit("Usage: python -m meltygui.utils.pkl_inspect SESSION.pkl [--depth=N]")
+    path = args[0]
+    depth = 2
+    for a in sys.argv[1:]:
+        if a.startswith("--depth"):
+            depth = int(a.split("=")[-1]) if "=" in a else int(sys.argv[sys.argv.index(a) + 1])
+    ClassUtility().initialize_class_names("meltygui")
+    sys.setrecursionlimit(1_000_000)
+    import os
+    print(f"file: {path}  ({os.path.getsize(path)/1024/1024:.2f} MB on disk)\n")
+    root = v2.load(path, run_on_load=False)
+    print(f"{'serialized':>11}  {'graph':>7}        field: type\n{'-'*70}")
+    dump_tree(root, depth=depth, min_kb=1.0)
+    print("\n(sizes are each subtree re-pickled in isolation; shared objects counted "
+          "under each referrer, so children can sum to more than the parent)")
+
+
+if __name__ == "__main__":
+    main()