pyprobe-plots 0.0.4__tar.gz

pyprobe_plots-0.0.4/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: pyprobe-plots
+Version: 0.0.4
+Summary: Variable probing based debugger for Python DSP debugging
+Author: PyProbe Contributors
+License: MIT
+Keywords: dsp,debugging,visualization,probe
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Debuggers
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6>=6.4.0
+Requires-Dist: pyqtgraph>=0.13.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pytest>=9.0.2
+Requires-Dist: matplotlib>=3.10.8
+Requires-Dist: scipy>=1.15.3
+Requires-Dist: pytest-qt>=4.5.0
+Requires-Dist: pytest-xdist>=3.8.0
+Requires-Dist: pytest-forked>=1.6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-qt>=4.0.0; extra == "dev"

pyprobe_plots-0.0.4/pyprobe/__init__.py

@@ -0,0 +1,3 @@
+"""PyProbe: Variable probing based debugger for Python DSP debugging."""
+
+__version__ = "0.1.0"

pyprobe_plots-0.0.4/pyprobe/__main__.py

@@ -0,0 +1,121 @@
+"""
+PyProbe entry point.
+
+Usage:
+    python -m pyprobe [script.py]
+    python -m pyprobe --loglevel DEBUG examples/dsp_demo.py
+    python -m pyprobe --trace-states examples/dsp_demo.py
+"""
+
+import sys
+import os
+import argparse
+
+
+def main():
+    """Main entry point for PyProbe."""
+    parser = argparse.ArgumentParser(
+        description="PyProbe - Variable probing based debugger for Python DSP debugging"
+    )
+    parser.add_argument(
+        "script",
+        nargs="?",
+        help="Python script to probe (optional, can be loaded from GUI)"
+    )
+    parser.add_argument(
+        "--auto-run",
+        action="store_true",
+        help="Automatically run the script after loading"
+    )
+    parser.add_argument(
+        "--auto-quit",
+        action="store_true",
+        help="Automatically quit the application when the script finishes"
+    )
+    parser.add_argument(
+        "--auto-quit-timeout",
+        type=float,
+        default=None,
+        help="Force quit after specified seconds, even if errors prevent normal auto-quit (default: infinite)"
+    )
+    parser.add_argument(
+        "-p", "--probe",
+        action="append",
+        help="Add graphical probe. Format: line:symbol:instance (e.g., 4:x:1)"
+    )
+    parser.add_argument(
+        "-w", "--watch",
+        action="append",
+        help="Add scalar watch. Format: line:symbol:instance (e.g., 4:x:1)"
+    )
+    parser.add_argument(
+        "--overlay",
+        action="append",
+        help="Overlay a signal on an existing probe. Format: target_symbol:line:symbol:instance "
+             "(e.g., signal_i:75:received_symbols:1 overlays received_symbols onto signal_i)"
+    )
+    parser.add_argument(
+        "-l", "--loglevel",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="WARNING",
+        help="Set logging level (default: WARNING). DEBUG writes to /tmp/pyprobe_debug.log"
+    )
+    parser.add_argument(
+        "--logfile",
+        default="/tmp/pyprobe_debug.log",
+        help="Log file path (default: /tmp/pyprobe_debug.log)"
+    )
+    parser.add_argument(
+        "--log-console",
+        action="store_true",
+        help="Also log to console (stderr)"
+    )
+
+    parser.add_argument(
+        "--trace-states",
+        action="store_true",
+        help="Enable detailed state tracing. Logs all user actions and reactions to /tmp/pyprobe_state_trace.log"
+    )
+
+    args = parser.parse_args()
+
+    # Initialize state tracer FIRST if requested
+    if args.trace_states:
+        from pyprobe.state_tracer import init_tracer
+        init_tracer(enabled=True)
+        print("State tracing enabled. Log: /tmp/pyprobe_state_trace.log")
+
+    # Setup logging before importing anything else
+    from pyprobe.logging import setup_logging
+    setup_logging(
+        level=args.loglevel,
+        log_file=args.logfile,
+        console=args.log_console
+    )
+
+    # Import here to avoid slow startup for --help
+    from pyprobe.gui.app import run_app
+
+    # Auto-detect file vs. folder
+    script_path = args.script
+    folder_path = None
+    if script_path and os.path.isdir(script_path):
+        folder_path = os.path.abspath(script_path)
+        script_path = None
+
+    # Run the application
+    sys.exit(run_app(
+        script_path=script_path,
+        folder_path=folder_path,
+        probes=args.probe,
+        watches=args.watch,
+        overlays=args.overlay,
+        auto_run=args.auto_run,
+        auto_quit=args.auto_quit,
+        auto_quit_timeout=args.auto_quit_timeout
+    ))
+
+
+if __name__ == "__main__":
+    main()
+

pyprobe_plots-0.0.4/pyprobe/analysis/__init__.py

@@ -0,0 +1,4 @@
+"""Source code analysis utilities."""
+from .ast_locator import ASTLocator
+
+__all__ = ['ASTLocator']

pyprobe_plots-0.0.4/pyprobe/analysis/anchor_mapper.py

@@ -0,0 +1,220 @@
+"""Anchor mapping for preserving probe locations across file edits."""
+import difflib
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Set
+
+from pyprobe.core.anchor import ProbeAnchor
+from pyprobe.analysis.ast_locator import ASTLocator
+
+
+@dataclass
+class AnchorMapping:
+    """Result of mapping an anchor from old source to new source."""
+    old_anchor: ProbeAnchor
+    new_anchor: Optional[ProbeAnchor]  # None if invalid
+    confidence: float  # 0.0 to 1.0
+
+
+class AnchorMapper:
+    """Maps probe anchors from old source to new source after file edits.
+
+    Mapping Strategy (4-tier confidence):
+    - 1.0 (Exact): Same (line, col, symbol, func) exists after line shift
+    - 0.7 (Near): Same (symbol, func) exists nearby (within same function)
+    - 0.4 (Weak): Only symbol exists anywhere in file
+    - 0.0 (Invalid): Cannot find symbol at all
+    """
+
+    def __init__(self, old_source: str, new_source: str, filepath: str):
+        """Initialize mapper with old and new source code.
+
+        Args:
+            old_source: The original source code
+            new_source: The modified source code
+            filepath: The file path (for creating new anchors)
+        """
+        self._old_source = old_source
+        self._new_source = new_source
+        self._filepath = filepath
+
+        # Parse both sources
+        self._old_locator = ASTLocator(old_source, filepath)
+        self._new_locator = ASTLocator(new_source, filepath)
+
+        # Compute line mapping from old to new
+        self._line_map = self._compute_line_map()
+
+    def _compute_line_map(self) -> Dict[int, int]:
+        """Use difflib to map old line numbers to new line numbers.
+
+        Returns:
+            Dict mapping old line number (1-indexed) to new line number (1-indexed).
+            Only includes lines that exist in both versions (unchanged lines).
+        """
+        old_lines = self._old_source.splitlines()
+        new_lines = self._new_source.splitlines()
+
+        matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
+        line_map: Dict[int, int] = {}
+
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == 'equal':
+                # Lines are identical - map each old line to corresponding new line
+                for offset in range(i2 - i1):
+                    old_line = i1 + offset + 1  # 1-indexed
+                    new_line = j1 + offset + 1  # 1-indexed
+                    line_map[old_line] = new_line
+
+        return line_map
+
+    def map_anchor(self, anchor: ProbeAnchor) -> AnchorMapping:
+        """Map a single anchor to its new location.
+
+        Args:
+            anchor: The probe anchor to map
+
+        Returns:
+            AnchorMapping with new_anchor (or None) and confidence score
+        """
+        # Tier 1: Exact match after line shift (confidence 1.0)
+        exact_result = self._try_exact_match(anchor)
+        if exact_result is not None:
+            return AnchorMapping(anchor, exact_result, 1.0)
+
+        # Tier 2: Symbol in same function nearby (confidence 0.7)
+        func_result = self._find_symbol_in_function(anchor)
+        if func_result is not None:
+            return AnchorMapping(anchor, func_result, 0.7)
+
+        # Tier 3: Symbol exists anywhere (confidence 0.4)
+        anywhere_result = self._find_symbol_anywhere(anchor)
+        if anywhere_result is not None:
+            return AnchorMapping(anchor, anywhere_result, 0.4)
+
+        # Tier 4: Invalid - symbol not found (confidence 0.0)
+        return AnchorMapping(anchor, None, 0.0)
+
+    def _try_exact_match(self, anchor: ProbeAnchor) -> Optional[ProbeAnchor]:
+        """Try to find exact match at mapped line position.
+
+        Returns new anchor if the same symbol exists at the same column
+        on the mapped line within the same function.
+        """
+        # Check if old line maps to a new line
+        if anchor.line not in self._line_map:
+            return None
+
+        new_line = self._line_map[anchor.line]
+
+        # Check if same symbol exists at same column on new line
+        var_name = self._new_locator.get_var_at_cursor(new_line, anchor.col)
+        if var_name != anchor.symbol:
+            return None
+
+        # Verify same enclosing function
+        new_func = self._new_locator.get_enclosing_function(new_line) or ""
+        if new_func != anchor.func:
+            return None
+
+        # Exact match found
+        return ProbeAnchor(
+            file=self._filepath,
+            line=new_line,
+            col=anchor.col,
+            symbol=anchor.symbol,
+            func=new_func,
+        )
+
+    def _find_symbol_in_function(self, anchor: ProbeAnchor) -> Optional[ProbeAnchor]:
+        """Find the same symbol within the same function.
+
+        Searches for the symbol in the new source, preferring occurrences
+        within the same function.
+        """
+        if not anchor.func:
+            # No function context to search within
+            return None
+
+        # Find all variables in new source
+        new_lines = self._new_source.splitlines()
+        for line_num in range(1, len(new_lines) + 1):
+            # Check if this line is in the same function
+            func_name = self._new_locator.get_enclosing_function(line_num)
+            if func_name != anchor.func:
+                continue
+
+            # Check for symbol on this line
+            vars_on_line = self._new_locator.get_all_variables_on_line(line_num)
+            for var in vars_on_line:
+                if var.name == anchor.symbol:
+                    return ProbeAnchor(
+                        file=self._filepath,
+                        line=line_num,
+                        col=var.col_start,
+                        symbol=anchor.symbol,
+                        func=func_name or "",
+                    )
+
+        return None
+
+    def _find_symbol_anywhere(self, anchor: ProbeAnchor) -> Optional[ProbeAnchor]:
+        """Find first occurrence of symbol anywhere in new source."""
+        new_lines = self._new_source.splitlines()
+        for line_num in range(1, len(new_lines) + 1):
+            vars_on_line = self._new_locator.get_all_variables_on_line(line_num)
+            for var in vars_on_line:
+                if var.name == anchor.symbol:
+                    func_name = self._new_locator.get_enclosing_function(line_num)
+                    return ProbeAnchor(
+                        file=self._filepath,
+                        line=line_num,
+                        col=var.col_start,
+                        symbol=anchor.symbol,
+                        func=func_name or "",
+                    )
+
+        return None
+
+    def map_all(self, anchors: List[ProbeAnchor]) -> List[AnchorMapping]:
+        """Map all anchors and return list of mappings.
+
+        Args:
+            anchors: List of probe anchors to map
+
+        Returns:
+            List of AnchorMapping results
+        """
+        return [self.map_anchor(anchor) for anchor in anchors]
+
+    def get_invalidated(self, anchors: List[ProbeAnchor]) -> Set[ProbeAnchor]:
+        """Return set of anchors that could not be mapped (invalid).
+
+        Args:
+            anchors: List of probe anchors to check
+
+        Returns:
+            Set of anchors with confidence 0.0 (no new_anchor)
+        """
+        invalid: Set[ProbeAnchor] = set()
+        for anchor in anchors:
+            mapping = self.map_anchor(anchor)
+            if mapping.new_anchor is None:
+                invalid.add(anchor)
+        return invalid
+
+    def get_valid_mappings(self, anchors: List[ProbeAnchor]) -> Dict[ProbeAnchor, ProbeAnchor]:
+        """Return dict of old anchor -> new anchor for valid mappings.
+
+        Args:
+            anchors: List of probe anchors to map
+
+        Returns:
+            Dict mapping old anchors to their new locations
+            (only includes anchors with confidence > 0.0)
+        """
+        valid: Dict[ProbeAnchor, ProbeAnchor] = {}
+        for anchor in anchors:
+            mapping = self.map_anchor(anchor)
+            if mapping.new_anchor is not None:
+                valid[mapping.old_anchor] = mapping.new_anchor
+        return valid

pyprobe_plots-0.0.4/pyprobe/analysis/ast_locator.py

@@ -0,0 +1,265 @@
+"""AST-based source code analysis for variable location."""
+import ast
+from enum import Enum
+from typing import Optional, List, Tuple, Set
+from dataclasses import dataclass, field
+
+from pyprobe.logging import get_logger, trace_print
+
+logger = get_logger(__name__)
+
+
+class SymbolType(Enum):
+    """Classification of symbol types for probeability determination."""
+    DATA_VARIABLE = "data"      # LHS of assignment → PROBEABLE
+    FUNCTION_CALL = "call"      # Function being called → NOT probeable
+    MODULE_REF = "module"       # Module access (np.xyz) → NOT probeable
+    FUNCTION_DEF = "func_def"   # Function name in def → NOT probeable
+    UNKNOWN = "unknown"         # Default → NOT probeable
+
+
+@dataclass
+class VariableLocation:
+    """Location of a variable in source code."""
+    name: str
+    line: int       # 1-indexed
+    col_start: int  # 0-indexed
+    col_end: int    # 0-indexed, exclusive
+    is_lhs: bool    # True if assignment target
+    symbol_type: SymbolType = field(default=SymbolType.UNKNOWN)
+
+
+class ASTLocator:
+    """Maps cursor positions to AST nodes and variable names.
+
+    Key features:
+    - Column-aware variable detection
+    - LHS preference for ambiguous positions (x = x + 1)
+    - Function scope detection
+    """
+
+    def __init__(self, source: str, filename: str = "<string>"):
+        self._source = source
+        self._filename = filename
+        self._tree: Optional[ast.AST] = None
+        self._variables: List[VariableLocation] = []
+        self._functions: List[Tuple[str, int, int]] = []  # (name, start_line, end_line)
+        self._parse()
+
+    def _parse(self) -> None:
+        """Parse source and extract variable locations."""
+        try:
+            self._tree = ast.parse(self._source, filename=self._filename)
+        except SyntaxError:
+            self._tree = None
+            return
+
+        self._extract_variables()
+        self._extract_functions()
+
+    def _extract_variables(self) -> None:
+        """Extract all Name nodes with their locations and symbol types."""
+        if self._tree is None:
+            return
+
+        # Collect positions for each symbol type
+        lhs_positions: Set[Tuple[int, int]] = set()
+        call_positions: Set[Tuple[int, int]] = set()  # Function calls
+        module_positions: Set[Tuple[int, int]] = set()  # Attribute base (e.g., np in np.sin)
+        func_def_positions: Set[Tuple[int, int]] = set()  # Function/class def names
+
+        self._collect_lhs_positions_from_tree(self._tree, lhs_positions)
+        self._collect_special_positions(self._tree, call_positions, module_positions, func_def_positions)
+
+        # Now collect all Name nodes and classify them
+        for node in ast.walk(self._tree):
+            if isinstance(node, ast.Name):
+                pos = (node.lineno, node.col_offset)
+                
+                # Determine symbol type (priority order matters)
+                if pos in lhs_positions:
+                    symbol_type = SymbolType.DATA_VARIABLE
+                elif pos in func_def_positions:
+                    symbol_type = SymbolType.FUNCTION_DEF
+                elif pos in call_positions:
+                    symbol_type = SymbolType.FUNCTION_CALL
+                elif pos in module_positions:
+                    symbol_type = SymbolType.MODULE_REF
+                else:
+                    symbol_type = SymbolType.UNKNOWN
+                
+                is_lhs = pos in lhs_positions
+                var_loc = VariableLocation(
+                    name=node.id,
+                    line=node.lineno,
+                    col_start=node.col_offset,
+                    col_end=node.end_col_offset or (node.col_offset + len(node.id)),
+                    is_lhs=is_lhs,
+                    symbol_type=symbol_type,
+                )
+                self._variables.append(var_loc)
+                # Debug trace for line 72 variables
+                if node.lineno == 72 and node.id in ('received_symbols', 'signal_i', 'signal_q'):
+                    trace_print(f"ASTLocator: {node.id} at L{node.lineno}:C{node.col_offset} pos={pos}, is_lhs={is_lhs}, lhs_positions contains? {pos in lhs_positions}")
+                logger.debug(f"Classified {node.id} at L{node.lineno}:C{node.col_offset} as {symbol_type}")
+
+    def _collect_special_positions(
+        self, 
+        tree: ast.AST, 
+        call_positions: Set[Tuple[int, int]],
+        module_positions: Set[Tuple[int, int]],
+        func_def_positions: Set[Tuple[int, int]]
+    ) -> None:
+        """Collect positions of function calls, module refs, and function defs."""
+        for node in ast.walk(tree):
+            # Function definitions - the function name itself
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                # Note: node.name is just a string, but we need to find corresponding Name nodes
+                # Function defs don't have Name nodes for their own name, so we track line/col
+                # Actually FunctionDef.name is a str, not a Name node, so this won't be in _variables
+                pass
+            
+            # Class definitions - similar, class name is a string attribute
+            if isinstance(node, ast.ClassDef):
+                pass
+            
+            # Function calls
+            if isinstance(node, ast.Call):
+                func = node.func
+                # Direct call: foo()
+                if isinstance(func, ast.Name):
+                    call_positions.add((func.lineno, func.col_offset))
+                # Method call: obj.method() - mark 'obj' as module ref
+                elif isinstance(func, ast.Attribute):
+                    self._collect_attribute_base_positions(func, module_positions)
+            
+            # Attribute access (not a call, just np.something)
+            if isinstance(node, ast.Attribute):
+                # If this attribute is the value of another attribute (nested: np.sin.something)
+                # or if it's part of a call (np.sin()), we handle module refs
+                self._collect_attribute_base_positions(node, module_positions)
+
+    def _collect_attribute_base_positions(
+        self, 
+        node: ast.Attribute, 
+        positions: Set[Tuple[int, int]]
+    ) -> None:
+        """Recursively collect base Name positions from attribute chains."""
+        val = node.value
+        if isinstance(val, ast.Name):
+            # This is the base of the attribute chain (e.g., 'np' in np.sin)
+            positions.add((val.lineno, val.col_offset))
+        elif isinstance(val, ast.Attribute):
+            # Nested attribute, recurse
+            self._collect_attribute_base_positions(val, positions)
+
+    def _collect_lhs_positions_from_tree(self, tree: ast.AST, positions: Set[Tuple[int, int]]) -> None:
+        """Walk tree and collect all assignment target positions."""
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    self._collect_lhs_positions(target, positions)
+            elif isinstance(node, ast.AnnAssign) and node.target:
+                self._collect_lhs_positions(node.target, positions)
+            elif isinstance(node, ast.AugAssign):
+                self._collect_lhs_positions(node.target, positions)
+            elif isinstance(node, (ast.For, ast.comprehension)):
+                self._collect_lhs_positions(node.target, positions)
+
+    def _collect_lhs_positions(self, node: ast.AST, positions: Set[Tuple[int, int]]) -> None:
+        """Recursively collect positions of assignment targets."""
+        if isinstance(node, ast.Name):
+            positions.add((node.lineno, node.col_offset))
+        elif isinstance(node, (ast.Tuple, ast.List)):
+            for elt in node.elts:
+                self._collect_lhs_positions(elt, positions)
+
+    def _extract_functions(self) -> None:
+        """Extract function definitions with their line ranges."""
+        if self._tree is None:
+            return
+
+        for node in ast.walk(self._tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                end_line = node.end_lineno or node.lineno
+                self._functions.append((node.name, node.lineno, end_line))
+
+    def get_var_at_cursor(self, line: int, col: int) -> Optional[str]:
+        """Return variable name at cursor position, or None.
+
+        If multiple variables overlap (rare), prefer LHS.
+        """
+        candidates = []
+        for var in self._variables:
+            if var.line == line and var.col_start <= col < var.col_end:
+                candidates.append(var)
+
+        if not candidates:
+            return None
+
+        # Prefer LHS if ambiguous
+        lhs_candidates = [v for v in candidates if v.is_lhs]
+        if lhs_candidates:
+            return lhs_candidates[0].name
+
+        return candidates[0].name
+
+    def get_var_location_at_cursor(self, line: int, col: int) -> Optional[VariableLocation]:
+        """Return full VariableLocation at cursor, or None."""
+        for var in self._variables:
+            if var.line == line and var.col_start <= col < var.col_end:
+                return var
+        return None
+
+    def get_all_variables_on_line(self, line: int) -> List[VariableLocation]:
+        """Return all variables on a given line."""
+        return [v for v in self._variables if v.line == line]
+
+    def get_enclosing_function(self, line: int) -> Optional[str]:
+        """Return name of function containing this line, or None."""
+        for name, start, end in self._functions:
+            if start <= line <= end:
+                return name
+        return None
+
+    def get_nearest_variable(self, line: int, col: int) -> Optional[VariableLocation]:
+        """Find nearest variable to cursor position.
+
+        First checks exact match, then looks on same line within 3 chars.
+        """
+        # Exact match
+        exact = self.get_var_location_at_cursor(line, col)
+        if exact:
+            return exact
+
+        # Same line, within proximity
+        line_vars = self.get_all_variables_on_line(line)
+        if not line_vars:
+            return None
+
+        # Find closest by column distance
+        def distance(v: VariableLocation) -> int:
+            if v.col_start <= col < v.col_end:
+                return 0
+            return min(abs(col - v.col_start), abs(col - v.col_end))
+
+        closest = min(line_vars, key=distance)
+        if distance(closest) <= 3:  # Snap within 3 chars
+            return closest
+
+        return None
+
+    def is_probeable(self, var_loc: VariableLocation) -> bool:
+        """Return True if this variable can be probed.
+        
+        Only DATA_VARIABLE symbols (LHS of assignments) are probeable.
+        Function calls, module references, and unknown symbols are not.
+        """
+        result = var_loc.symbol_type == SymbolType.DATA_VARIABLE
+        logger.debug(f"is_probeable({var_loc.name}): type={var_loc.symbol_type}, result={result}")
+        return result
+
+    @property
+    def is_valid(self) -> bool:
+        """Return True if source was parsed successfully."""
+        return self._tree is not None

pyprobe_plots-0.0.4/pyprobe/analysis/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for analysis module."""