asterrdetection 0.1.0__py3-none-any.whl

ast_error_detection/__init__.py

@@ -0,0 +1,17 @@
+# This file is part of ast_error_detection.
+# Copyright (C) 2025 Badmavasan.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or any later version.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from .error_diagnosis import get_code_errors
+
+__all__ = [
+    "get_code_errors"
+]
+
+__version__ = "0.1.0"

ast_error_detection/annotated_tree.py

@@ -0,0 +1,173 @@
+# This file is part of ast_error_detection.
+# Copyright (C) 2025 Badmavasan.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or any later version.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+class AnnotatedTree:
+    """
+    A class representing an annotated tree structure used in the Zhang-Shasha tree edit distance algorithm.
+
+    This class attaches additional information to each node in a tree to facilitate the computation of the
+    minimal edit distance between two trees. It does so by performing a post-order traversal and computing:
+
+    - Post-order node IDs.
+    - The Leftmost Leaf Descendant (LMD) of each node.
+    - Keyroots, which are nodes that represent roots of subproblems in the Zhang-Shasha algorithm.
+
+    Attributes:
+        get_children (callable): A function that, given a node, returns a list of its children.
+        root (Node): The root node of the tree.
+        nodes (list): A list of nodes in the tree in post-order.
+        ids (list): A list of integer IDs corresponding to each node, assigned in post-order.
+        lmds (list): A list of leftmost leaf descendant indices (LMDs) for each node.
+        keyroots (list): A list of keyroot indices used in the tree edit distance computation.
+        nodes_path (list): A list of paths (lists of labels) for each node from the root.
+
+    The AnnotatedTree is designed to work hand-in-hand with the Zhang-Shasha distance algorithm. The trees
+    are processed so that each node has a unique post-order ID and an associated LMD, allowing for efficient
+    dynamic programming computation of the edit distance.
+    """
+
+    def __init__(self, root, get_children):
+        """
+        Initialize the AnnotatedTree with the given root and get_children function.
+
+        Args:
+            root (Node): The root node of the tree.
+            get_children (callable): A function or method that takes a node and returns a list of its children.
+        """
+        self.get_children = get_children
+        self.root = root
+        self.nodes = []
+        self.ids = []
+        self.lmds = []
+        self.keyroots = []
+        self.nodes_path = []  # Store the path from the root to each node
+        self._build(root)
+
+    def _build(self, node):
+        """
+        Build the annotated tree data structures by performing a post-order traversal from the given node.
+
+        This method initializes counters and mappings, then delegates to the recursive `_compute_post_order`
+        method to populate the `nodes`, `ids`, and `lmds`. Finally, it computes the keyroots based on the LMD
+        information.
+        """
+        self._id_counter = 0
+        self._lmd_mapping = {}
+        self._compute_post_order(node)
+        self.keyroots = self._compute_keyroots()
+
+    def _compute_post_order(self, node):
+        """
+        Recursively compute post-order traversal to assign IDs, determine LMDs, and record paths.
+
+        During the traversal:
+          - Each node is assigned a post-order ID.
+          - The leftmost leaf descendant (LMD) of each node is determined.
+          - The path from the root to the node is recorded.
+          - Results are appended to class-level lists: `nodes`, `ids`, and `lmds`.
+
+        Args:
+            node (Node): The current node being processed.
+
+        Returns:
+            int: The LMD index of the current node.
+        """
+        # Retrieve children of the current node
+        children = self.get_children(node)
+        lmd = None
+
+        # Post-order: first process children
+        for child in children:
+            child_lmd = self._compute_post_order(child)
+            if lmd is None:
+                # The LMD of the first child encountered will be the LMD of this node
+                lmd = child_lmd
+
+        # Assign post-order ID to the current node
+        node_id = self._id_counter
+        self._id_counter += 1
+        self.nodes.append(node)
+
+        # Store the path from the root to this node
+        path = node.get_path()
+        self.nodes_path.append(path)
+
+        self.ids.append(node_id)
+
+        # If no children, this is a leaf node; its LMD is itself
+        if lmd is None:
+            lmd = node_id
+
+        self.lmds.append(lmd)
+        self._lmd_mapping[node_id] = lmd
+
+        return lmd
+
+    def _compute_keyroots(self):
+        """
+        Compute the keyroots for the tree.
+
+        Keyroots are defined as follows:
+        - For each leftmost leaf descendant index (LMD) in `self.lmds`, the last occurrence of that LMD
+          identifies a keyroot.
+        - Keyroots are then sorted by their indices.
+
+        Returns:
+            list: A sorted list of keyroot indices.
+        """
+        lmd_to_index = {}
+        # Map each LMD to its last occurrence in the list
+        for index, lmd in enumerate(self.lmds):
+            lmd_to_index[lmd] = index
+
+        # Keyroots are the final occurrences of each LMD, sorted by their indices
+        keyroots = sorted(lmd_to_index.values())
+        return keyroots
+
+    def print_tree_structure(self, name):
+        """
+        Print a human-readable representation of the tree structure.
+
+        This method is intended to help with debugging or understanding the current tree layout
+        after it has been processed into an `AnnotatedTree`. It displays each node with:
+        - Its index in the post-order traversal list.
+        - The path from the root to this node.
+        - The node's label.
+        - The labels of its children in the current order.
+
+        Args:
+            name (str): A descriptive name for the tree, used as a heading in the output.
+
+        Example:
+            If the tree structure is:
+                Module
+                    For
+                        Condition:
+                            Var: i
+                            Call: range
+                                Const: 5
+                        Body:
+                            Call: print
+                                Const: 'hello'
+
+        The output might look like:
+            --- Code1 Tree Structure ---
+            Node 0: Path: ['Module', 'For[0]', 'Condition:[0]', 'Var: i[0]'] | Label: 'Var: i' | Children Order: []
+            Node 1: Path: ['Module', 'For[0]', 'Condition:[0]', 'Call: range[1]'] | Label: 'Call: range' | Children Order: ['Const: 5']
+            ...
+        """
+        print(f"--- {name} Tree Structure ---")
+        for idx, node in enumerate(self.nodes):
+            path = node.get_path()
+            label = node.label
+            children_labels = [child.label for child in node.children]
+            print(f"Node {idx}: Path: {path} | Label: '{label}' | Children Order: {children_labels}")
+

ast_error_detection/convert_ast_to_custom_node.py

@@ -0,0 +1,245 @@
+# This file is part of ast_error_detection.
+# Copyright (C) 2025 Badmavasan.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or any later version.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import ast
+from node import Node
+
+
+def handle_comparison(comparison_node):
+    # Mapping of AST comparison types to their string representation.
+    comparison_ops = {
+        ast.Gt: '>',
+        ast.Lt: '<',
+        ast.LtE: '<=',
+        ast.GtE: '>=',
+        ast.Eq: '==',
+        ast.NotEq: '!=',
+        ast.In: 'In',
+        ast.NotIn: 'Not in'
+    }
+
+    operator = comparison_node.ops[0]
+    operator_label = comparison_ops.get(type(operator), '')
+
+    left_nodes = ast_to_custom_node(comparison_node.left)
+    right_nodes = ast_to_custom_node(comparison_node.comparators[0])
+
+    condition_children = left_nodes + right_nodes
+    node_label = (
+        f"Compare: {operator_label}"
+        if operator_label not in ('In', 'Not in')
+        else f"Call: {operator_label}"
+    )
+
+    return [Node(node_label, children=condition_children)]
+
+
+def process_child_nodes(ast_node):
+    children = []
+    for child in ast.iter_child_nodes(ast_node):
+        child_nodes = ast_to_custom_node(child)
+        if child_nodes:
+            children.extend(child_nodes)
+    return children
+
+
+def ast_to_custom_node(ast_node):
+    """
+    Transforms an AST node into a Tree using Node
+
+    Returns:
+        Node: Tree object representing ast_node
+    """
+    node_type = type(ast_node).__name__
+
+    # Skip 'Load' or 'Store' node types.
+    if node_type in {'Load', 'Store'}:
+        return []
+
+    # Handle 'Expr' nodes.
+    elif node_type == 'Expr':
+        return process_child_nodes(ast_node)
+
+    # Handle 'UnaryOp' nodes.
+    elif node_type == 'UnaryOp':
+        if isinstance(ast_node.op, ast.USub):
+            if isinstance(ast_node.operand, ast.Constant):
+                return [Node(f"Const: -{ast_node.operand.value}")]
+            elif isinstance(ast_node.operand, ast.Name):
+                return [Node(f"Var: -{ast_node.operand.id}")]
+        return []
+
+    # Handle function definitions.
+    elif isinstance(ast_node, ast.FunctionDef):
+        children = process_child_nodes(ast_node)
+        return [Node(f"Function: {ast_node.name}", children=children)]
+
+    # Handle function arguments.
+    elif isinstance(ast_node, ast.arg):
+        return [Node(f"Arg: {ast_node.arg}")]
+
+    # Handle function argument lists.
+    elif isinstance(ast_node, ast.arguments):
+        children = process_child_nodes(ast_node)
+        if children:
+            return [Node("arguments", children=children)]
+        return []
+
+    # Handle binary operations and augmented assignments.
+    elif isinstance(ast_node, (ast.BinOp, ast.AugAssign)):
+        op_labels = {
+            ast.Mod: '%',
+            ast.Add: '+',
+            ast.Sub: '-',
+            ast.Mult: '*',
+            ast.Div: '/',
+            ast.FloorDiv: '//',
+            ast.Pow: '**',
+        }
+        op_type = type(ast_node.op)
+        op_label = op_labels.get(op_type, 'Operation')
+
+        children = []
+        if isinstance(ast_node, ast.BinOp):
+            left_nodes = ast_to_custom_node(ast_node.left)
+            right_nodes = ast_to_custom_node(ast_node.right)
+            children.extend(left_nodes + right_nodes)
+        elif isinstance(ast_node, ast.AugAssign):
+            target_nodes = ast_to_custom_node(ast_node.target)
+            value_nodes = ast_to_custom_node(ast_node.value)
+            children.extend(target_nodes + value_nodes)
+
+        return [Node(f"Operation: {op_label}", children=children)]
+
+    # Handle 'For' loops.
+    elif isinstance(ast_node, ast.For):
+        loop_var_nodes = ast_to_custom_node(ast_node.target)
+        iter_nodes = ast_to_custom_node(ast_node.iter)
+        condition_node = Node("Condition:", children=loop_var_nodes + iter_nodes)
+
+        body_nodes = []
+        for stmt in ast_node.body:
+            body_nodes.extend(ast_to_custom_node(stmt))
+
+        children = [condition_node, Node("Body:", children=body_nodes)]
+        return [Node("For", children=children)]
+
+    # Handle variable assignments.
+    elif isinstance(ast_node, ast.Assign):
+        nodes = []
+        if isinstance(ast_node.targets[0], ast.Tuple) and isinstance(ast_node.value, ast.Tuple):
+            for target, value in zip(ast_node.targets[0].elts, ast_node.value.elts):
+                target_label = f"Var: {target.id}"
+                value_label = (
+                    f"Const: {value.value}" if isinstance(value, ast.Constant) else f"Var: {value.id}"
+                )
+                nodes.append(Node("Assign", children=[Node(target_label), Node(value_label)]))
+        else:
+            target_label = f"Var: {ast_node.targets[0].id}"
+            value_nodes = ast_to_custom_node(ast_node.value)
+            nodes.append(Node("Assign", children=[Node(target_label)] + value_nodes))
+        return nodes
+
+    # Handle conditional statements ('If') and loops ('While').
+    elif isinstance(ast_node, (ast.If, ast.While)):
+        children = []
+
+        # Handle the test condition
+        if isinstance(ast_node.test, ast.Compare):
+            condition_nodes = handle_comparison(ast_node.test)
+            children.append(Node("Condition:", children=condition_nodes))
+        elif isinstance(ast_node.test, ast.BoolOp):
+            boolop_children = []
+            for value in ast_node.test.values:
+                if isinstance(value, ast.Compare):
+                    boolop_children.extend(handle_comparison(value))
+                else:
+                    boolop_children.extend(ast_to_custom_node(value))
+            op_name = type(ast_node.test.op).__name__
+            children.append(Node(f"Cond. set: {op_name}", children=boolop_children))
+        elif (
+                isinstance(ast_node.test, ast.UnaryOp)
+                and isinstance(ast_node.test.op, ast.Not)
+                and isinstance(ast_node.test.operand, ast.Compare)
+        ):
+            condition_nodes = handle_comparison(ast_node.test.operand)
+            children.append(Node("Condition:", children=[Node("Call: Not")] + condition_nodes))
+        else:
+            test_nodes = ast_to_custom_node(ast_node.test)
+            if test_nodes:
+                children.append(Node("Condition:", children=test_nodes))
+
+        # Handle the body
+        body_nodes = []
+        for stmt in ast_node.body:
+            body_nodes.extend(ast_to_custom_node(stmt))
+        if body_nodes:
+            children.append(Node("Body:", children=body_nodes))
+
+        # Handle the else part
+        else_nodes = []
+        for stmt in ast_node.orelse:
+            else_nodes.extend(ast_to_custom_node(stmt))
+        if else_nodes:
+            children.append(Node("Else:", children=else_nodes))
+
+        return [Node(node_type, children=children)]
+
+    # Handle list constructs.
+    elif isinstance(ast_node, ast.List):
+        elements = []
+        for elt in ast_node.elts:
+            if isinstance(elt, ast.Constant):
+                elements.append(str(elt.value))
+            elif isinstance(elt, ast.Name):
+                elements.append(elt.id)
+        elements_str = ', '.join(elements)
+        return [Node(f"Const: [{elements_str}]")]
+
+    # Handle variable subscripts.
+    elif isinstance(ast_node, ast.Subscript):
+        value_nodes = ast_to_custom_node(ast_node.value)
+        slice_nodes = ast_to_custom_node(ast_node.slice)
+        return value_nodes + [Node("Sliced by", children=slice_nodes)]
+
+    # Handle comparison constructs.
+    elif isinstance(ast_node, ast.Compare):
+        return handle_comparison(ast_node)
+
+    # Default case for other node types.
+    else:
+        if isinstance(ast_node, ast.Constant):
+            value = ast_node.value
+            formatted_value = f"'{value}'" if isinstance(value, str) else str(value)
+            return [Node(f"Const: {formatted_value}")]
+        elif isinstance(ast_node, ast.Call):
+            children = []
+            for arg in ast_node.args:
+                children.extend(ast_to_custom_node(arg))
+            func_name = ast_node.func.id if hasattr(ast_node.func, "id") else "Unknown"
+            return [Node(f"Call: {func_name}", children=children)]
+        elif isinstance(ast_node, ast.Name):
+            return [Node(f"Var: {ast_node.id}")]
+        elif isinstance(ast_node, ast.Module):
+            children = process_child_nodes(ast_node)
+            return [Node("Module", children=children)]
+        elif isinstance(ast_node, ast.Return):
+            value_nodes = ast_to_custom_node(ast_node.value)
+            return [Node("Return", children=value_nodes)]
+        elif isinstance(ast_node, ast.alias):
+            return [Node(f"alias: {ast_node.name}")]
+        elif isinstance(ast_node, ast.ImportFrom):
+            names_nodes = []
+            for alias in ast_node.names:
+                names_nodes.extend(ast_to_custom_node(alias))
+            return [Node(f"ImportFrom: {ast_node.module}", children=names_nodes)]
+        else:
+            children = process_child_nodes(ast_node)
+            return [Node(node_type, children=children)]