vex-ast 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

vex_ast/__init__.py

@@ -1,81 +1,81 @@
-"""
-VEX AST Generator Package.
-
-Provides tools for parsing VEX V5 code and generating an Abstract Syntax Tree (AST).
-"""
-
-# Core functionality
-from .ast.core import Program
-from .parser.python_parser import parse_string, parse_file
-
-# AST Navigation
-from .ast.navigator import AstNavigator, create_navigator
-
-# Visitors
-from .visitors.printer import PrintVisitor
-from .visitors.analyzer import NodeCounter, VariableCollector
-
-# Error handling
-from .utils.errors import ErrorHandler, ErrorType, VexSyntaxError, VexAstError, Error
-
-# Registry
-from .registry.api import registry_api
-from .registry import initialize
-
-# Serialization
-from .serialization.json_serializer import serialize_ast_to_dict, serialize_ast_to_json
-from .serialization.json_deserializer import deserialize_ast_from_dict, deserialize_ast_from_json
-from .serialization.schema import generate_ast_schema, export_schema_to_file
-
-__version__ = "0.2.0"
-
-# Initialize the registry with default functions
-try:
-    # Explicitly import and initialize all registry functions
-    from .registry.functions.initialize import initialize_registry
-    initialize_registry()
-    
-    # Verify registry has been populated
-    if len(registry_api.get_all_functions()) == 0:
-        print("Warning: Registry initialization did not populate any functions")
-    else:
-        print(f"VEX function registry initialized successfully with {len(registry_api.get_all_functions())} functions")
-except Exception as e:
-    print(f"Error initializing VEX function registry: {e}")
-    import traceback
-    traceback.print_exc()
-
-__all__ = [
-    # Core functionality
-    "Program",
-    "parse_string",
-    "parse_file",
-    
-    # AST Navigation
-    "AstNavigator",
-    "create_navigator",
-    
-    # Visitors
-    "PrintVisitor",
-    "NodeCounter",
-    "VariableCollector",
-    
-    # Error handling
-    "ErrorHandler",
-    "ErrorType",
-    "VexSyntaxError",
-    "VexAstError",
-    "Error",
-    
-    # Registry
-    "registry_api",
-    "initialize",
-    
-    # Serialization
-    "serialize_ast_to_dict",
-    "serialize_ast_to_json",
-    "deserialize_ast_from_dict",
-    "deserialize_ast_from_json",
-    "generate_ast_schema",
-    "export_schema_to_file"
-]
+"""
+VEX AST Generator Package.
+
+Provides tools for parsing VEX V5 code and generating an Abstract Syntax Tree (AST).
+"""
+
+# Core functionality
+from .ast.core import Program
+from .parser.python_parser import parse_string, parse_file
+
+# AST Navigation
+from .ast.navigator import AstNavigator, create_navigator
+
+# Visitors
+from .visitors.printer import PrintVisitor
+from .visitors.analyzer import NodeCounter, VariableCollector
+
+# Error handling
+from .utils.errors import ErrorHandler, ErrorType, VexSyntaxError, VexAstError, Error
+
+# Registry
+from .registry.api import registry_api
+from .registry import initialize
+
+# Serialization
+from .serialization.json_serializer import serialize_ast_to_dict, serialize_ast_to_json
+from .serialization.json_deserializer import deserialize_ast_from_dict, deserialize_ast_from_json
+from .serialization.schema import generate_ast_schema, export_schema_to_file
+
+__version__ = "0.2.0"
+
+# Initialize the registry with default functions
+try:
+    # Explicitly import and initialize all registry functions
+    from .registry.functions.initialize import initialize_registry
+    initialize_registry()
+    
+    # Verify registry has been populated
+    if len(registry_api.get_all_functions()) == 0:
+        print("Warning: Registry initialization did not populate any functions")
+    else:
+        print(f"VEX function registry initialized successfully with {len(registry_api.get_all_functions())} functions")
+except Exception as e:
+    print(f"Error initializing VEX function registry: {e}")
+    import traceback
+    traceback.print_exc()
+
+__all__ = [
+    # Core functionality
+    "Program",
+    "parse_string",
+    "parse_file",
+    
+    # AST Navigation
+    "AstNavigator",
+    "create_navigator",
+    
+    # Visitors
+    "PrintVisitor",
+    "NodeCounter",
+    "VariableCollector",
+    
+    # Error handling
+    "ErrorHandler",
+    "ErrorType",
+    "VexSyntaxError",
+    "VexAstError",
+    "Error",
+    
+    # Registry
+    "registry_api",
+    "initialize",
+    
+    # Serialization
+    "serialize_ast_to_dict",
+    "serialize_ast_to_json",
+    "deserialize_ast_from_dict",
+    "deserialize_ast_from_json",
+    "generate_ast_schema",
+    "export_schema_to_file"
+]

vex_ast/ast/README.md

@@ -1,87 +1,87 @@
-AST Node Definitions (vex_ast.ast)
-
-This directory defines the structure and types of nodes used in the Abstract Syntax Tree (AST) representation of VEX V5 Python code.
-
-Purpose
-
-The AST provides a structured, hierarchical representation of the source code, abstracting away the specific syntax details. This structure is the foundation for analysis, transformation, and interpretation of the code.
-
-Core Concepts
-
-Interfaces (interfaces.py): Defines the fundamental protocols (IAstNode, IExpression, IStatement, ILiteral, IVisitor) that all nodes and visitors adhere to. This ensures a consistent structure.
-
-Base Classes (core.py): Provides abstract base classes (AstNode, Expression, Statement) that implement common functionality like location tracking and the basic accept method for the Visitor pattern. Program is the root node type.
-
-Visitor Pattern: Each node implements an accept(visitor) method, allowing external IVisitor objects to operate on the AST without modifying the node classes themselves.
-
-Child Nodes: Each node provides a get_children() method to facilitate traversal of the tree.
-
-Source Location: Nodes can store optional SourceLocation information (from vex_ast.utils) linking them back to the original code.
-
-Node Categories
-
-The AST nodes are organized into logical categories:
-
-Expressions (expressions.py): Represent code constructs that evaluate to a value.
-
-Identifier: Variable names, function names.
-
-VariableReference: Usage of a variable.
-
-AttributeAccess: Accessing attributes (e.g., motor.spin).
-
-BinaryOperation: Operations like +, -, *, /, ==, and, or.
-
-UnaryOperation: Operations like - (negation), not.
-
-FunctionCall: Calling functions or methods.
-
-KeywordArgument: Named arguments in function calls (e.g., speed=50).
-
-Literals (literals.py): Represent constant values.
-
-NumberLiteral: Integers and floats.
-
-StringLiteral: Text strings.
-
-BooleanLiteral: True or False.
-
-NoneLiteral: The None value.
-
-Statements (statements.py): Represent actions or control flow constructs.
-
-ExpressionStatement: An expression used on its own line (e.g., a function call).
-
-Assignment: Assigning a value to a variable (=).
-
-IfStatement: Conditional execution (if/elif/else).
-
-WhileLoop: Looping based on a condition.
-
-ForLoop: Iterating over a sequence.
-
-FunctionDefinition: Defining a function (def).
-
-Argument: Parameters in a function definition.
-
-ReturnStatement: Returning a value from a function.
-
-BreakStatement, ContinueStatement: Loop control.
-
-Operators (operators.py): Defines Operator enums used within BinaryOperation and UnaryOperation nodes. Includes mappings from Python operators.
-
-VEX-Specific Nodes (vex_nodes.py): Subclasses of FunctionCall tailored to represent common VEX API patterns.
-
-VexAPICall: Base class for VEX calls.
-
-MotorControl: Calls related to motors (e.g., motor.spin).
-
-SensorReading: Calls related to sensors (e.g., sensor.value).
-
-TimingControl: Calls like wait.
-
-DisplayOutput: Calls related to screen output (e.g., brain.screen.print).
-
-Usage
-
-These node classes are typically instantiated by the parser (vex_ast.parser) during the code parsing process. Visitors (vex_ast.visitors) then interact with these node objects to perform tasks.
+AST Node Definitions (vex_ast.ast)
+
+This directory defines the structure and types of nodes used in the Abstract Syntax Tree (AST) representation of VEX V5 Python code.
+
+Purpose
+
+The AST provides a structured, hierarchical representation of the source code, abstracting away the specific syntax details. This structure is the foundation for analysis, transformation, and interpretation of the code.
+
+Core Concepts
+
+Interfaces (interfaces.py): Defines the fundamental protocols (IAstNode, IExpression, IStatement, ILiteral, IVisitor) that all nodes and visitors adhere to. This ensures a consistent structure.
+
+Base Classes (core.py): Provides abstract base classes (AstNode, Expression, Statement) that implement common functionality like location tracking and the basic accept method for the Visitor pattern. Program is the root node type.
+
+Visitor Pattern: Each node implements an accept(visitor) method, allowing external IVisitor objects to operate on the AST without modifying the node classes themselves.
+
+Child Nodes: Each node provides a get_children() method to facilitate traversal of the tree.
+
+Source Location: Nodes can store optional SourceLocation information (from vex_ast.utils) linking them back to the original code.
+
+Node Categories
+
+The AST nodes are organized into logical categories:
+
+Expressions (expressions.py): Represent code constructs that evaluate to a value.
+
+Identifier: Variable names, function names.
+
+VariableReference: Usage of a variable.
+
+AttributeAccess: Accessing attributes (e.g., motor.spin).
+
+BinaryOperation: Operations like +, -, *, /, ==, and, or.
+
+UnaryOperation: Operations like - (negation), not.
+
+FunctionCall: Calling functions or methods.
+
+KeywordArgument: Named arguments in function calls (e.g., speed=50).
+
+Literals (literals.py): Represent constant values.
+
+NumberLiteral: Integers and floats.
+
+StringLiteral: Text strings.
+
+BooleanLiteral: True or False.
+
+NoneLiteral: The None value.
+
+Statements (statements.py): Represent actions or control flow constructs.
+
+ExpressionStatement: An expression used on its own line (e.g., a function call).
+
+Assignment: Assigning a value to a variable (=).
+
+IfStatement: Conditional execution (if/elif/else).
+
+WhileLoop: Looping based on a condition.
+
+ForLoop: Iterating over a sequence.
+
+FunctionDefinition: Defining a function (def).
+
+Argument: Parameters in a function definition.
+
+ReturnStatement: Returning a value from a function.
+
+BreakStatement, ContinueStatement: Loop control.
+
+Operators (operators.py): Defines Operator enums used within BinaryOperation and UnaryOperation nodes. Includes mappings from Python operators.
+
+VEX-Specific Nodes (vex_nodes.py): Subclasses of FunctionCall tailored to represent common VEX API patterns.
+
+VexAPICall: Base class for VEX calls.
+
+MotorControl: Calls related to motors (e.g., motor.spin).
+
+SensorReading: Calls related to sensors (e.g., sensor.value).
+
+TimingControl: Calls like wait.
+
+DisplayOutput: Calls related to screen output (e.g., brain.screen.print).
+
+Usage
+
+These node classes are typically instantiated by the parser (vex_ast.parser) during the code parsing process. Visitors (vex_ast.visitors) then interact with these node objects to perform tasks.

vex_ast/ast/__init__.py

@@ -1,75 +1,75 @@
-"""Abstract Syntax Tree (AST) package for VEX code."""
-
-# Core AST classes
-from .interfaces import (
-    IAstNode, IExpression, IStatement, ILiteral, IIdentifier, IFunctionCall, IAssignment,
-    IVisitor, T_VisitorResult, AstNode
-)
-from .core import Expression, Statement, Program
-from .expressions import (
-    Identifier, VariableReference, AttributeAccess,
-    BinaryOperation, UnaryOperation, FunctionCall, KeywordArgument
-)
-from .statements import (
-    ExpressionStatement, Assignment, Argument, FunctionDefinition,
-    IfStatement, WhileLoop, ForLoop, ReturnStatement,
-    BreakStatement, ContinueStatement
-)
-from .literals import (
-    Literal, NumberLiteral, StringLiteral, BooleanLiteral, NoneLiteral
-)
-from .operators import Operator
-from .vex_nodes import (
-    VexAPICallType, VexAPICall, MotorControl, SensorReading,
-    TimingControl, DisplayOutput, create_vex_api_call,
-    create_vex_api_call_from_interface
-)
-from .validators import validate_vex_functions, VexFunctionValidator
-from .navigator import AstNavigator
-
-# Expose the navigator as a factory function
-def create_navigator(root: IAstNode) -> AstNavigator:
-    """Create an AST navigator for the given root node.
-    
-    Args:
-        root: The root node of the AST
-        
-    Returns:
-        An AST navigator for traversing and querying the AST
-    """
-    return AstNavigator(root)
-
-__all__ = [
-    # Interfaces
-    'IAstNode', 'IExpression', 'IStatement', 'ILiteral', 'IIdentifier', 
-    'IFunctionCall', 'IAssignment', 'IVisitor', 'T_VisitorResult', 'AstNode',
-    
-    # Core
-    'Expression', 'Statement', 'Program',
-    
-    # Expressions
-    'Identifier', 'VariableReference', 'AttributeAccess',
-    'BinaryOperation', 'UnaryOperation', 'FunctionCall', 'KeywordArgument',
-    
-    # Statements
-    'ExpressionStatement', 'Assignment', 'Argument', 'FunctionDefinition',
-    'IfStatement', 'WhileLoop', 'ForLoop', 'ReturnStatement',
-    'BreakStatement', 'ContinueStatement',
-    
-    # Literals
-    'Literal', 'NumberLiteral', 'StringLiteral', 'BooleanLiteral', 'NoneLiteral',
-    
-    # Operators
-    'Operator',
-    
-    # VEX-specific
-    'VexAPICallType', 'VexAPICall', 'MotorControl', 'SensorReading',
-    'TimingControl', 'DisplayOutput', 'create_vex_api_call',
-    'create_vex_api_call_from_interface',
-    
-    # Validators
-    'validate_vex_functions', 'VexFunctionValidator',
-    
-    # Navigator
-    'AstNavigator', 'create_navigator',
+"""Abstract Syntax Tree (AST) package for VEX code."""
+
+# Core AST classes
+from .interfaces import (
+    IAstNode, IExpression, IStatement, ILiteral, IIdentifier, IFunctionCall, IAssignment,
+    IVisitor, T_VisitorResult, AstNode
+)
+from .core import Expression, Statement, Program
+from .expressions import (
+    Identifier, VariableReference, AttributeAccess,
+    BinaryOperation, UnaryOperation, FunctionCall, KeywordArgument
+)
+from .statements import (
+    ExpressionStatement, Assignment, Argument, FunctionDefinition,
+    IfStatement, WhileLoop, ForLoop, ReturnStatement,
+    BreakStatement, ContinueStatement
+)
+from .literals import (
+    Literal, NumberLiteral, StringLiteral, BooleanLiteral, NoneLiteral
+)
+from .operators import Operator
+from .vex_nodes import (
+    VexAPICallType, VexAPICall, MotorControl, SensorReading,
+    TimingControl, DisplayOutput, create_vex_api_call,
+    create_vex_api_call_from_interface
+)
+from .validators import validate_vex_functions, VexFunctionValidator
+from .navigator import AstNavigator
+
+# Expose the navigator as a factory function
+def create_navigator(root: IAstNode) -> AstNavigator:
+    """Create an AST navigator for the given root node.
+    
+    Args:
+        root: The root node of the AST
+        
+    Returns:
+        An AST navigator for traversing and querying the AST
+    """
+    return AstNavigator(root)
+
+__all__ = [
+    # Interfaces
+    'IAstNode', 'IExpression', 'IStatement', 'ILiteral', 'IIdentifier', 
+    'IFunctionCall', 'IAssignment', 'IVisitor', 'T_VisitorResult', 'AstNode',
+    
+    # Core
+    'Expression', 'Statement', 'Program',
+    
+    # Expressions
+    'Identifier', 'VariableReference', 'AttributeAccess',
+    'BinaryOperation', 'UnaryOperation', 'FunctionCall', 'KeywordArgument',
+    
+    # Statements
+    'ExpressionStatement', 'Assignment', 'Argument', 'FunctionDefinition',
+    'IfStatement', 'WhileLoop', 'ForLoop', 'ReturnStatement',
+    'BreakStatement', 'ContinueStatement',
+    
+    # Literals
+    'Literal', 'NumberLiteral', 'StringLiteral', 'BooleanLiteral', 'NoneLiteral',
+    
+    # Operators
+    'Operator',
+    
+    # VEX-specific
+    'VexAPICallType', 'VexAPICall', 'MotorControl', 'SensorReading',
+    'TimingControl', 'DisplayOutput', 'create_vex_api_call',
+    'create_vex_api_call_from_interface',
+    
+    # Validators
+    'validate_vex_functions', 'VexFunctionValidator',
+    
+    # Navigator
+    'AstNavigator', 'create_navigator',
 ]

vex_ast/ast/core.py

@@ -1,71 +1,71 @@
-"""Core AST node implementations."""
-
-from typing import Any, Dict, List, Optional, Union, cast
-
-from .interfaces import AstNode, IAstNode, IExpression, IStatement, IVisitor, T_VisitorResult
-from ..utils.source_location import SourceLocation
-
-class Expression(AstNode):
-    """Base class for expression nodes."""
-    
-    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
-        """Default implementation that defers to visitor."""
-        method_name = f"visit_{self.__class__.__name__.lower()}"
-        if hasattr(visitor, method_name):
-            return getattr(visitor, method_name)(self)
-        return visitor.visit_expression(self)
-
-class Statement(AstNode):
-    """Base class for statement nodes."""
-    
-    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
-        """Default implementation that defers to visitor."""
-        method_name = f"visit_{self.__class__.__name__.lower()}"
-        if hasattr(visitor, method_name):
-            return getattr(visitor, method_name)(self)
-        return visitor.visit_statement(self)
-
-class Program(AstNode):
-    """Root node of the AST, representing the entire program."""
-    
-    _fields = ('body',)
-    
-    def __init__(self, body: List[IStatement], location: Optional[SourceLocation] = None):
-        super().__init__(location)
-        self.body = body
-        
-        # Set parent references
-        for statement in self.body:
-            if isinstance(statement, AstNode):
-                statement.set_parent(self)
-    
-    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
-        """Accept a visitor."""
-        return visitor.visit_program(self)
-    
-    def get_children(self) -> List[IAstNode]:
-        """Get child nodes."""
-        return cast(List[IAstNode], self.body)
-    
-    def get_statements(self) -> List[IStatement]:
-        """Get all statements in the program."""
-        return self.body
-    
-    def add_statement(self, statement: IStatement) -> None:
-        """Add a statement to the program."""
-        self.body.append(statement)
-        if isinstance(statement, AstNode):
-            statement.set_parent(self)
-    
-    def insert_statement(self, index: int, statement: IStatement) -> None:
-        """Insert a statement at a specific position."""
-        self.body.insert(index, statement)
-        if isinstance(statement, AstNode):
-            statement.set_parent(self)
-    
-    def remove_statement(self, statement: IStatement) -> bool:
-        """Remove a statement from the program."""
-        if statement in self.body:
-            self.body.remove(statement)
-            return True
-        return False
+"""Core AST node implementations."""
+
+from typing import Any, Dict, List, Optional, Union, cast
+
+from .interfaces import AstNode, IAstNode, IExpression, IStatement, IVisitor, T_VisitorResult
+from ..utils.source_location import SourceLocation
+
+class Expression(AstNode):
+    """Base class for expression nodes."""
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        """Default implementation that defers to visitor."""
+        method_name = f"visit_{self.__class__.__name__.lower()}"
+        if hasattr(visitor, method_name):
+            return getattr(visitor, method_name)(self)
+        return visitor.visit_expression(self)
+
+class Statement(AstNode):
+    """Base class for statement nodes."""
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        """Default implementation that defers to visitor."""
+        method_name = f"visit_{self.__class__.__name__.lower()}"
+        if hasattr(visitor, method_name):
+            return getattr(visitor, method_name)(self)
+        return visitor.visit_statement(self)
+
+class Program(AstNode):
+    """Root node of the AST, representing the entire program."""
+    
+    _fields = ('body',)
+    
+    def __init__(self, body: List[IStatement], location: Optional[SourceLocation] = None):
+        super().__init__(location)
+        self.body = body
+        
+        # Set parent references
+        for statement in self.body:
+            if isinstance(statement, AstNode):
+                statement.set_parent(self)
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        """Accept a visitor."""
+        return visitor.visit_program(self)
+    
+    def get_children(self) -> List[IAstNode]:
+        """Get child nodes."""
+        return cast(List[IAstNode], self.body)
+    
+    def get_statements(self) -> List[IStatement]:
+        """Get all statements in the program."""
+        return self.body
+    
+    def add_statement(self, statement: IStatement) -> None:
+        """Add a statement to the program."""
+        self.body.append(statement)
+        if isinstance(statement, AstNode):
+            statement.set_parent(self)
+    
+    def insert_statement(self, index: int, statement: IStatement) -> None:
+        """Insert a statement at a specific position."""
+        self.body.insert(index, statement)
+        if isinstance(statement, AstNode):
+            statement.set_parent(self)
+    
+    def remove_statement(self, statement: IStatement) -> bool:
+        """Remove a statement from the program."""
+        if statement in self.body:
+            self.body.remove(statement)
+            return True
+        return False