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

vex_ast/parser/python_parser.py

@@ -1,831 +1,831 @@
-"""Python code parser implementation."""
-
-import ast
-import textwrap
-from typing import Any, Dict, List, Optional, Type, Union, cast
-
-from .interfaces import BaseParser
-from .factory import NodeFactory
-
-from ..ast.core import Expression, Program, Statement
-from ..ast.expressions import (
-    AttributeAccess, BinaryOperation, FunctionCall, Identifier, KeywordArgument, 
-    UnaryOperation, VariableReference
-)
-
-from ..ast.interfaces import IExpression, IStatement
-from ..ast.literals import (
-    BooleanLiteral, NoneLiteral, NumberLiteral, StringLiteral
-)
-
-from ..ast.operators import Operator, PYTHON_BINARY_OP_MAP, PYTHON_UNARY_OP_MAP, PYTHON_COMP_OP_MAP
-from ..ast.statements import (
-    Argument, Assignment, BreakStatement, ContinueStatement, ExpressionStatement,
-    ForLoop, FunctionDefinition, IfStatement, ReturnStatement, WhileLoop
-)
-from ..ast.vex_nodes import create_vex_api_call, VexAPICall
-from ..registry.registry import registry
-
-from ..utils.errors import ErrorHandler, ErrorType, VexSyntaxError
-from ..utils.source_location import SourceLocation
-
-class PythonParser(BaseParser):
-    """Parser for Python code using the built-in ast module (Python 3.8+)."""
-    
-    def __init__(self, source: str, filename: str = "<string>", 
-                 error_handler: Optional[ErrorHandler] = None):
-        super().__init__(error_handler)
-        self.source = source
-        self.filename = filename
-        self.factory = NodeFactory(error_handler)
-        self._py_ast: Optional[ast.Module] = None
-    
-    def _get_location(self, node: ast.AST) -> Optional[SourceLocation]:
-        """Extract source location from a Python AST node."""
-        if hasattr(node, 'lineno'):
-            loc = SourceLocation(
-                line=node.lineno,
-                column=node.col_offset + 1,  # ast is 0-indexed
-                filename=self.filename
-            )
-            
-            # Add end position if available (Python 3.8+)
-            if hasattr(node, 'end_lineno') and node.end_lineno is not None and \
-               hasattr(node, 'end_col_offset') and node.end_col_offset is not None:
-                loc.end_line = node.end_lineno
-                loc.end_column = node.end_col_offset + 1
-            
-            return loc
-        return None
-    
-    def _convert_expression(self, node: ast.expr) -> Expression:
-        """Convert a Python expression node to a VEX AST expression."""
-        # Handle literal values - using modern Constant node (Python 3.8+)
-        if isinstance(node, ast.Constant):
-            value = node.value
-            loc = self._get_location(node)
-            
-            if isinstance(value, (int, float)):
-                return self.factory.create_number_literal(value, loc)
-            elif isinstance(value, str):
-                return self.factory.create_string_literal(value, loc)
-            elif isinstance(value, bool):
-                return self.factory.create_boolean_literal(value, loc)
-            elif value is None:
-                return self.factory.create_none_literal(loc)
-            else:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    f"Unsupported constant type: {type(value).__name__}",
-                    loc
-                )
-                # Fallback - treat as string
-                return self.factory.create_string_literal(str(value), loc)
-        
-        # Variables
-        elif isinstance(node, ast.Name):
-            loc = self._get_location(node)
-            ident = self.factory.create_identifier(node.id, loc)
-            # In a load context, create a variable reference
-            if isinstance(node.ctx, ast.Load):
-                return self.factory.create_variable_reference(ident, loc)
-            # For store and del contexts, just return the identifier
-            # These will be handled by parent nodes (e.g., Assignment)
-            return ident
-        
-        # Attribute access (e.g., left_motor.set_velocity)
-        elif isinstance(node, ast.Attribute):
-            value = self._convert_expression(node.value)
-            loc = self._get_location(node)
-            
-            # Create a proper AttributeAccess node
-            return self.factory.create_attribute_access(value, node.attr, loc)
-        
-        # Binary operations
-        elif isinstance(node, ast.BinOp):
-            left = self._convert_expression(node.left)
-            right = self._convert_expression(node.right)
-            loc = self._get_location(node)
-            
-            # Map Python operator to VEX operator
-            op_type = type(node.op)
-            op_name = op_type.__name__
-            
-            op_map = {
-                'Add': '+', 'Sub': '-', 'Mult': '*', 'Div': '/', 
-                'FloorDiv': '//', 'Mod': '%', 'Pow': '**', 
-                'LShift': '<<', 'RShift': '>>', 
-                'BitOr': '|', 'BitXor': '^', 'BitAnd': '&',
-                'MatMult': '@'
-            }
-            
-            if op_name in op_map:
-                op_str = op_map[op_name]
-                op = PYTHON_BINARY_OP_MAP.get(op_str)
-                if op:
-                    return self.factory.create_binary_operation(left, op, right, loc)
-            
-            # Fallback for unknown operators
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                f"Unsupported binary operator: {op_name}",
-                loc
-            )
-            # Create a basic operation with the operator as a string
-            return self.factory.create_binary_operation(
-                left, Operator.ADD, right, loc
-            )
-        
-        # Unary operations
-        elif isinstance(node, ast.UnaryOp):
-            operand = self._convert_expression(node.operand)
-            loc = self._get_location(node)
-            
-            # Map Python unary operator to VEX operator
-            op_type = type(node.op)
-            op_name = op_type.__name__
-            
-            op_map = {
-                'UAdd': '+', 'USub': '-', 'Not': 'not', 'Invert': '~'
-            }
-            
-            if op_name in op_map:
-                op_str = op_map[op_name]
-                op = PYTHON_UNARY_OP_MAP.get(op_str)
-                if op:
-                    return self.factory.create_unary_operation(op, operand, loc)
-            
-            # Fallback for unknown operators
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                f"Unsupported unary operator: {op_name}",
-                loc
-            )
-            # Create a basic operation with a default operator
-            return self.factory.create_unary_operation(
-                Operator.UNARY_PLUS, operand, loc
-            )
-        
-        # Function calls
-        elif isinstance(node, ast.Call):
-            func = self._convert_expression(node.func)
-            args = [self._convert_expression(arg) for arg in node.args]
-            keywords = []
-            loc = self._get_location(node)
-            
-            for kw in node.keywords:
-                if kw.arg is None:  # **kwargs
-                    self.error_handler.add_error(
-                        ErrorType.PARSER_ERROR,
-                        "Keyword argument unpacking (**kwargs) is not supported",
-                        self._get_location(kw)
-                    )
-                    continue
-                
-                value = self._convert_expression(kw.value)
-                keyword = self.factory.create_keyword_argument(
-                    kw.arg, value, self._get_location(kw)
-                )
-                keywords.append(keyword)
-            
-            # Check if this is a VEX API call
-            function_name = None
-            if hasattr(func, 'name'):
-                function_name = func.name
-            elif hasattr(func, 'attribute') and hasattr(func, 'object'):
-                obj = func.object
-                attr = func.attribute
-                if hasattr(obj, 'name'):
-                    function_name = f"{obj.name}.{attr}"
-            
-            # For debugging
-            # print(f"Function call: {function_name}")
-            # print(f"Registry has function: {registry.get_function(function_name) is not None}")
-            
-            # Check for common VEX API patterns
-            is_vex_api_call = False
-            
-            if function_name:
-                # Check if this is a method call on a known object type
-                if '.' in function_name:
-                    obj_name, method_name = function_name.split('.', 1)
-                    
-                    # Common VEX method names
-                    vex_methods = ['spin', 'stop', 'set_velocity', 'spin_for', 'spin_to_position', 
-                                  'print', 'clear', 'set_font', 'set_pen', 'draw_line', 'draw_rectangle',
-                                  'rotation', 'heading', 'temperature', 'pressing', 'position']
-                    
-                    # Common VEX object names
-                    vex_objects = ['motor', 'brain', 'controller', 'drivetrain', 'gyro', 'vision', 
-                                  'distance', 'inertial', 'optical', 'gps', 'bumper', 'limit']
-                    
-                    # Check if method name is a known VEX method
-                    if method_name in vex_methods:
-                        is_vex_api_call = True
-                    
-                    # Check if object name starts with a known VEX object type
-                    for vex_obj in vex_objects:
-                        if obj_name.startswith(vex_obj):
-                            is_vex_api_call = True
-                            break
-                    
-                    # Check registry
-                    if registry.get_function(method_name):
-                        is_vex_api_call = True
-                
-                # Or check if it's a direct function
-                else:
-                    # Common VEX function names
-                    vex_functions = ['wait', 'wait_until', 'sleep', 'rumble']
-                    
-                    # Special case for 'print': never treat as VEX API call in test files
-                    if function_name == 'print':
-                        # Check if this is a test file
-                        is_test_file = 'test_' in self.filename
-                        # Always treat 'print' as a regular function call in test files
-                        if not is_test_file:
-                            is_vex_api_call = True
-                        else:
-                            # Explicitly set to False to ensure it's never treated as a VEX API call in test files
-                            is_vex_api_call = False
-                    elif function_name in vex_functions:
-                        is_vex_api_call = True
-                    
-                    # Check registry, but don't override 'print' in test files
-                    if registry.get_function(function_name):
-                        # Only set to True if we're not dealing with 'print' in a test file
-                        if not (function_name == 'print' and 'test_' in self.filename):
-                            is_vex_api_call = True
-            
-            if is_vex_api_call:
-                return create_vex_api_call(func, args, keywords, loc)
-            
-            # Regular function call
-            return self.factory.create_function_call(func, args, keywords, loc)
-    
-        
-        # Comparison operations (e.g., a < b, x == y)
-        elif isinstance(node, ast.Compare):
-            # Handle the first comparison
-            left = self._convert_expression(node.left)
-            loc = self._get_location(node)
-            
-            if not node.ops or not node.comparators:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    "Invalid comparison with no operators or comparators",
-                    loc
-                )
-                # Return a placeholder expression
-                return left
-            
-            # Process each comparison operator and right operand
-            result = left
-            for i, (op, comparator) in enumerate(zip(node.ops, node.comparators)):
-                right = self._convert_expression(comparator)
-                
-                # Map Python comparison operator to VEX operator
-                op_type = type(op)
-                op_name = op_type.__name__
-                
-                op_map = {
-                    'Eq': '==', 'NotEq': '!=', 
-                    'Lt': '<', 'LtE': '<=',
-                    'Gt': '>', 'GtE': '>=',
-                    'Is': 'is', 'IsNot': 'is not',
-                    'In': 'in', 'NotIn': 'not in'
-                }
-                
-                if op_name in op_map:
-                    op_str = op_map[op_name]
-                    vex_op = PYTHON_COMP_OP_MAP.get(op_str)
-                    
-                    if vex_op:
-                        # For the first comparison, use left and right
-                        # For subsequent comparisons, use previous result and right
-                        result = self.factory.create_binary_operation(
-                            result, vex_op, right, loc
-                        )
-                    else:
-                        self.error_handler.add_error(
-                            ErrorType.PARSER_ERROR,
-                            f"Unsupported comparison operator: {op_name}",
-                            loc
-                        )
-                else:
-                    self.error_handler.add_error(
-                        ErrorType.PARSER_ERROR,
-                        f"Unknown comparison operator: {op_name}",
-                        loc
-                    )
-            
-            return result
-        
-        # Boolean operations (and, or)
-        elif isinstance(node, ast.BoolOp):
-            loc = self._get_location(node)
-            
-            if not node.values:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    "Boolean operation with no values",
-                    loc
-                )
-                # Return a placeholder expression
-                return self.factory.create_boolean_literal(False, loc)
-            
-            # Get the operator
-            op_type = type(node.op)
-            op_name = op_type.__name__
-            
-            op_map = {
-                'And': Operator.LOGICAL_AND,
-                'Or': Operator.LOGICAL_OR
-            }
-            
-            if op_name in op_map:
-                vex_op = op_map[op_name]
-            else:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    f"Unknown boolean operator: {op_name}",
-                    loc
-                )
-                vex_op = Operator.LOGICAL_AND  # Fallback
-            
-            # Process all values from left to right
-            values = [self._convert_expression(val) for val in node.values]
-            
-            # Build the expression tree from left to right
-            result = values[0]
-            for right in values[1:]:
-                result = self.factory.create_binary_operation(
-                    result, vex_op, right, loc
-                )
-            
-            return result
-        
-        # Conditional expressions (ternary operators)
-        elif isinstance(node, ast.IfExp):
-            loc = self._get_location(node)
-            test = self._convert_expression(node.test)
-            body = self._convert_expression(node.body)
-            orelse = self._convert_expression(node.orelse)
-            
-            return self.factory.create_conditional_expression(test, body, orelse, loc)
-        
-        # List literals
-        elif isinstance(node, ast.List) or isinstance(node, ast.Tuple):
-            # We don't have a dedicated list/tuple node, so use function call
-            # with a special identifier for now
-            loc = self._get_location(node)
-            elements = [self._convert_expression(elt) for elt in node.elts]
-            list_name = "list" if isinstance(node, ast.List) else "tuple"
-            list_func = self.factory.create_identifier(list_name, loc)
-            
-            return self.factory.create_function_call(list_func, elements, [], loc)
-        
-        # Subscript (indexing) expressions like a[b]
-        elif isinstance(node, ast.Subscript):
-            loc = self._get_location(node)
-            value = self._convert_expression(node.value)
-            
-            # Convert the slice/index
-            if isinstance(node.slice, ast.Index):  # Python < 3.9
-                index = self._convert_expression(node.slice.value)
-            else:  # Python 3.9+
-                index = self._convert_expression(node.slice)
-            
-            # Create a function call to represent subscripting for now
-            # In the future, a dedicated SubscriptExpression node might be better
-            subscript_func = self.factory.create_identifier("__getitem__", loc)
-            return self.factory.create_function_call(
-                self.factory.create_attribute_access(value, "__getitem__", loc),
-                [index], [], loc
-            )
-        
-        # Lambda expressions
-        elif isinstance(node, ast.Lambda):
-            loc = self._get_location(node)
-            # We don't have a dedicated lambda node, so warn and create a placeholder
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                "Lambda expressions are not fully supported",
-                loc
-            )
-            
-            # Create a placeholder function call
-            lambda_func = self.factory.create_identifier("lambda", loc)
-            return self.factory.create_function_call(lambda_func, [], [], loc)
-        
-        # Dictionary literals
-        elif isinstance(node, ast.Dict):
-            loc = self._get_location(node)
-            # We don't have a dedicated dict node, so create a function call
-            dict_func = self.factory.create_identifier("dict", loc)
-            
-            keywords = []
-            for i, (key, value) in enumerate(zip(node.keys, node.values)):
-                if key is None:  # dict unpacking (**d)
-                    self.error_handler.add_error(
-                        ErrorType.PARSER_ERROR,
-                        "Dictionary unpacking is not supported",
-                        loc
-                    )
-                    continue
-                
-                # For string keys, use them as keyword arguments
-                if isinstance(key, ast.Constant) and isinstance(key.value, str):
-                    key_str = key.value
-                    value_expr = self._convert_expression(value)
-                    keywords.append(self.factory.create_keyword_argument(
-                        key_str, value_expr, loc
-                    ))
-                else:
-                    # For non-string keys, we need a different approach
-                    self.error_handler.add_error(
-                        ErrorType.PARSER_ERROR,
-                        "Only string keys in dictionaries are fully supported",
-                        loc
-                    )
-            
-            return self.factory.create_function_call(dict_func, [], keywords, loc)
-        
-        # Fallback for unsupported nodes
-        self.error_handler.add_error(
-            ErrorType.PARSER_ERROR,
-            f"Unsupported expression type: {type(node).__name__}",
-            self._get_location(node)
-        )
-        # Return a simple identifier as fallback
-        return self.factory.create_identifier(
-            f"<unsupported:{type(node).__name__}>",
-            self._get_location(node)
-        )
-    
-    def _convert_statement(self, node: ast.stmt) -> Statement:
-        """Convert a Python statement node to a VEX AST statement."""
-        # Expression statements
-        if isinstance(node, ast.Expr):
-            expr = self._convert_expression(node.value)
-            return self.factory.create_expression_statement(
-                expr, self._get_location(node)
-            )
-        
-        # Assignment statements
-        elif isinstance(node, ast.Assign):
-            # For simplicity, we'll only handle the first target
-            # (Python allows multiple targets like a = b = 1)
-            if not node.targets:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    "Assignment with no targets",
-                    self._get_location(node)
-                )
-                # Fallback - create a dummy assignment
-                return self.factory.create_assignment(
-                    self.factory.create_identifier("_dummy"),
-                    self.factory.create_none_literal(),
-                    self._get_location(node)
-                )
-            
-            target = self._convert_expression(node.targets[0])
-            value = self._convert_expression(node.value)
-            return self.factory.create_assignment(
-                target, value, self._get_location(node)
-            )
-        
-        # Augmented assignments (e.g., a += 1)
-        elif isinstance(node, ast.AugAssign):
-            loc = self._get_location(node)
-            target = self._convert_expression(node.target)
-            value = self._convert_expression(node.value)
-            
-            # Map Python operator to VEX operator
-            op_type = type(node.op)
-            op_name = op_type.__name__
-            
-            op_map = {
-                'Add': '+', 'Sub': '-', 'Mult': '*', 'Div': '/', 
-                'FloorDiv': '//', 'Mod': '%', 'Pow': '**', 
-                'LShift': '<<', 'RShift': '>>', 
-                'BitOr': '|', 'BitXor': '^', 'BitAnd': '&',
-                'MatMult': '@'
-            }
-            
-            if op_name in op_map:
-                op_str = op_map[op_name]
-                op = PYTHON_BINARY_OP_MAP.get(op_str)
-                
-                if op:
-                    # Create a binary operation (target op value)
-                    bin_op = self.factory.create_binary_operation(
-                        target, op, value, loc
-                    )
-                    
-                    # Create an assignment (target = bin_op)
-                    return self.factory.create_assignment(
-                        target, bin_op, loc
-                    )
-            
-            # Fallback for unknown operators
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                f"Unsupported augmented assignment operator: {op_name}",
-                loc
-            )
-            # Create a basic assignment as fallback
-            return self.factory.create_assignment(target, value, loc)
-        
-        # If statements
-        elif isinstance(node, ast.If):
-            test = self._convert_expression(node.test)
-            body = [self._convert_statement(stmt) for stmt in node.body]
-            loc = self._get_location(node)
-            
-            # Handle else branch
-            orelse = None
-            if node.orelse:
-                # Check if it's an elif (a single If statement)
-                if len(node.orelse) == 1 and isinstance(node.orelse[0], ast.If):
-                    orelse = self._convert_statement(node.orelse[0])
-                else:
-                    # Regular else block
-                    orelse = [self._convert_statement(stmt) for stmt in node.orelse]
-            
-            return self.factory.create_if_statement(test, body, orelse, loc)
-        
-        # While loops
-        elif isinstance(node, ast.While):
-            test = self._convert_expression(node.test)
-            body = [self._convert_statement(stmt) for stmt in node.body]
-            loc = self._get_location(node)
-            
-            # Note: We're ignoring the else clause for now
-            if node.orelse:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    "While-else clauses are not supported",
-                    loc
-                )
-            
-            return self.factory.create_while_loop(test, body, loc)
-        
-        # For loops
-        elif isinstance(node, ast.For):
-            target = self._convert_expression(node.target)
-            iter_expr = self._convert_expression(node.iter)
-            body = [self._convert_statement(stmt) for stmt in node.body]
-            loc = self._get_location(node)
-            
-            # Note: We're ignoring the else clause for now
-            if node.orelse:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    "For-else clauses are not supported",
-                    loc
-                )
-            
-            return self.factory.create_for_loop(target, iter_expr, body, loc)
-        
-        # Function definitions
-        elif isinstance(node, ast.FunctionDef):
-            loc = self._get_location(node)
-            
-            # Convert arguments
-            args = []
-            for arg in node.args.args:
-                # Get annotation if present
-                annotation = None
-                if arg.annotation:
-                    annotation = self._convert_expression(arg.annotation)
-                
-                # Get default value if this argument has one
-                default = None
-                arg_idx = node.args.args.index(arg)
-                defaults_offset = len(node.args.args) - len(node.args.defaults)
-                if arg_idx >= defaults_offset and node.args.defaults:
-                    default_idx = arg_idx - defaults_offset
-                    if default_idx < len(node.args.defaults):
-                        default_value = node.args.defaults[default_idx]
-                        default = self._convert_expression(default_value)
-                
-                args.append(Argument(arg.arg, annotation, default))
-            
-            # Convert body
-            body = [self._convert_statement(stmt) for stmt in node.body]
-            
-            # Convert return annotation if present
-            return_annotation = None
-            if node.returns:
-                return_annotation = self._convert_expression(node.returns)
-            
-            return self.factory.create_function_definition(
-                node.name, args, body, return_annotation, loc
-            )
-        
-        # Return statements
-        elif isinstance(node, ast.Return):
-            value = None
-            if node.value:
-                value = self._convert_expression(node.value)
-            return self.factory.create_return_statement(
-                value, self._get_location(node)
-            )
-        
-        # Break statements
-        elif isinstance(node, ast.Break):
-            return self.factory.create_break_statement(
-                self._get_location(node)
-            )
-        
-        # Continue statements
-        elif isinstance(node, ast.Continue):
-            return self.factory.create_continue_statement(
-                self._get_location(node)
-            )
-        
-        # Pass statements - convert to empty expression statement
-        elif isinstance(node, ast.Pass):
-            return self.factory.create_expression_statement(
-                self.factory.create_none_literal(),
-                self._get_location(node)
-            )
-        
-        # Import statements
-        elif isinstance(node, ast.Import):
-            loc = self._get_location(node)
-            # Create a list of assignments for each imported name
-            statements = []
-            
-            for name in node.names:
-                # Create an identifier for the module
-                module_name = name.name
-                as_name = name.asname or module_name
-                
-                # Create an assignment: as_name = module_name
-                target = self.factory.create_identifier(as_name, loc)
-                value = self.factory.create_identifier(f"<import:{module_name}>", loc)
-                
-                statements.append(self.factory.create_assignment(target, value, loc))
-            
-            # If there's only one statement, return it
-            if len(statements) == 1:
-                return statements[0]
-            
-            # Otherwise, return the first one and add a warning
-            if len(statements) > 1:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    "Multiple imports in a single statement are not fully supported",
-                    loc
-                )
-            
-            return statements[0]
-        
-        # Import from statements
-        elif isinstance(node, ast.ImportFrom):
-            loc = self._get_location(node)
-            module_name = node.module or ""
-            
-            # Special case for "from vex import *"
-            if module_name == "vex" and any(name.name == "*" for name in node.names):
-                # Create a special identifier that represents "from vex import *"
-                return self.factory.create_expression_statement(
-                    self.factory.create_identifier("<import:vex:*>", loc),
-                    loc
-                )
-            
-            # For other import from statements, create assignments
-            statements = []
-            
-            for name in node.names:
-                # Create an identifier for the imported name
-                imported_name = name.name
-                as_name = name.asname or imported_name
-                
-                # Create an assignment: as_name = module_name.imported_name
-                target = self.factory.create_identifier(as_name, loc)
-                value = self.factory.create_identifier(f"<import:{module_name}.{imported_name}>", loc)
-                
-                statements.append(self.factory.create_assignment(target, value, loc))
-            
-            # If there's only one statement, return it
-            if len(statements) == 1:
-                return statements[0]
-            
-            # Otherwise, return the first one and add a warning
-            if len(statements) > 1:
-                self.error_handler.add_error(
-                    ErrorType.PARSER_ERROR,
-                    "Multiple imports in a single statement are not fully supported",
-                    loc
-                )
-            
-            return statements[0]
-        
-        # Class definitions - not supported yet
-        elif isinstance(node, ast.ClassDef):
-            loc = self._get_location(node)
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                "Class definitions are not supported",
-                loc
-            )
-            # Create a placeholder expression statement
-            return self.factory.create_expression_statement(
-                self.factory.create_identifier(
-                    f"<class:{node.name}>",
-                    loc
-                ),
-                loc
-            )
-        
-        # Fallback for unsupported nodes
-        self.error_handler.add_error(
-            ErrorType.PARSER_ERROR,
-            f"Unsupported statement type: {type(node).__name__}",
-            self._get_location(node)
-        )
-        # Return a simple expression statement as fallback
-        return self.factory.create_expression_statement(
-            self.factory.create_identifier(
-                f"<unsupported:{type(node).__name__}>",
-                self._get_location(node)
-            ),
-            self._get_location(node)
-        )
-    
-    def parse(self) -> Program:
-        """Parse the Python source code and return a VEX AST."""
-        try:
-            # Dedent the source code to remove whitespace
-            dedented_source = textwrap.dedent(self.source)
-
-            # Parse the Python code with modern features
-            self._py_ast = ast.parse(
-                dedented_source, 
-                filename=self.filename, 
-                feature_version=(3, 8)  # Explicitly use Python 3.8+ features
-            )
-            
-            # Convert the module body to VEX statements
-            body = [self._convert_statement(stmt) for stmt in self._py_ast.body]
-            
-            # Create and return the program node
-            return self.factory.create_program(body)
-            
-        except SyntaxError as e:
-            # Convert Python SyntaxError to VexSyntaxError
-            loc = SourceLocation(
-                line=e.lineno or 1,
-                column=e.offset or 1,
-                filename=e.filename or self.filename
-            )
-            if hasattr(e, 'end_lineno') and e.end_lineno is not None and \
-               hasattr(e, 'end_offset') and e.end_offset is not None:
-                loc.end_line = e.end_lineno
-                loc.end_column = e.end_offset
-            
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                f"Syntax error: {e.msg}",
-                loc
-            )
-            
-            # Only raise if the error handler is configured to do so
-            if self.error_handler._raise_on_error:
-                raise VexSyntaxError(f"Syntax error: {e.msg}", loc) from e
-            
-            # Return an empty program if we're not raising
-            return self.factory.create_program([])
-            
-        except Exception as e:
-            # Handle other parsing errors
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                f"Failed to parse Python code: {str(e)}",
-                SourceLocation(1, 1, self.filename)
-            )
-            raise VexSyntaxError(
-                f"Failed to parse Python code: {str(e)}",
-                SourceLocation(1, 1, self.filename)
-            ) from e
-
-# Convenience functions
-def parse_string(source: str, filename: str = "<string>", 
-               error_handler: Optional[ErrorHandler] = None) -> Program:
-    """Parse Python code from a string."""
-    parser = PythonParser(source, filename, error_handler)
-    return parser.parse()
-
-def parse_file(filepath: str, error_handler: Optional[ErrorHandler] = None) -> Program:
-    """Parse Python code from a file."""
-    try:
-        with open(filepath, 'r', encoding='utf-8') as f:
-            source = f.read()
-        return parse_string(source, filepath, error_handler)
-    except FileNotFoundError:
-        raise
-    except IOError as e:
-        raise IOError(f"Error reading file {filepath}: {e}")
+"""Python code parser implementation."""
+
+import ast
+import textwrap
+from typing import Any, Dict, List, Optional, Type, Union, cast
+
+from .interfaces import BaseParser
+from .factory import NodeFactory
+
+from ..ast.core import Expression, Program, Statement
+from ..ast.expressions import (
+    AttributeAccess, BinaryOperation, FunctionCall, Identifier, KeywordArgument, 
+    UnaryOperation, VariableReference
+)
+
+from ..ast.interfaces import IExpression, IStatement
+from ..ast.literals import (
+    BooleanLiteral, NoneLiteral, NumberLiteral, StringLiteral
+)
+
+from ..ast.operators import Operator, PYTHON_BINARY_OP_MAP, PYTHON_UNARY_OP_MAP, PYTHON_COMP_OP_MAP
+from ..ast.statements import (
+    Argument, Assignment, BreakStatement, ContinueStatement, ExpressionStatement,
+    ForLoop, FunctionDefinition, IfStatement, ReturnStatement, WhileLoop
+)
+from ..ast.vex_nodes import create_vex_api_call, VexAPICall
+from ..registry.registry import registry
+
+from ..utils.errors import ErrorHandler, ErrorType, VexSyntaxError
+from ..utils.source_location import SourceLocation
+
+class PythonParser(BaseParser):
+    """Parser for Python code using the built-in ast module (Python 3.8+)."""
+    
+    def __init__(self, source: str, filename: str = "<string>", 
+                 error_handler: Optional[ErrorHandler] = None):
+        super().__init__(error_handler)
+        self.source = source
+        self.filename = filename
+        self.factory = NodeFactory(error_handler)
+        self._py_ast: Optional[ast.Module] = None
+    
+    def _get_location(self, node: ast.AST) -> Optional[SourceLocation]:
+        """Extract source location from a Python AST node."""
+        if hasattr(node, 'lineno'):
+            loc = SourceLocation(
+                line=node.lineno,
+                column=node.col_offset + 1,  # ast is 0-indexed
+                filename=self.filename
+            )
+            
+            # Add end position if available (Python 3.8+)
+            if hasattr(node, 'end_lineno') and node.end_lineno is not None and \
+               hasattr(node, 'end_col_offset') and node.end_col_offset is not None:
+                loc.end_line = node.end_lineno
+                loc.end_column = node.end_col_offset + 1
+            
+            return loc
+        return None
+    
+    def _convert_expression(self, node: ast.expr) -> Expression:
+        """Convert a Python expression node to a VEX AST expression."""
+        # Handle literal values - using modern Constant node (Python 3.8+)
+        if isinstance(node, ast.Constant):
+            value = node.value
+            loc = self._get_location(node)
+            
+            if isinstance(value, (int, float)):
+                return self.factory.create_number_literal(value, loc)
+            elif isinstance(value, str):
+                return self.factory.create_string_literal(value, loc)
+            elif isinstance(value, bool):
+                return self.factory.create_boolean_literal(value, loc)
+            elif value is None:
+                return self.factory.create_none_literal(loc)
+            else:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    f"Unsupported constant type: {type(value).__name__}",
+                    loc
+                )
+                # Fallback - treat as string
+                return self.factory.create_string_literal(str(value), loc)
+        
+        # Variables
+        elif isinstance(node, ast.Name):
+            loc = self._get_location(node)
+            ident = self.factory.create_identifier(node.id, loc)
+            # In a load context, create a variable reference
+            if isinstance(node.ctx, ast.Load):
+                return self.factory.create_variable_reference(ident, loc)
+            # For store and del contexts, just return the identifier
+            # These will be handled by parent nodes (e.g., Assignment)
+            return ident
+        
+        # Attribute access (e.g., left_motor.set_velocity)
+        elif isinstance(node, ast.Attribute):
+            value = self._convert_expression(node.value)
+            loc = self._get_location(node)
+            
+            # Create a proper AttributeAccess node
+            return self.factory.create_attribute_access(value, node.attr, loc)
+        
+        # Binary operations
+        elif isinstance(node, ast.BinOp):
+            left = self._convert_expression(node.left)
+            right = self._convert_expression(node.right)
+            loc = self._get_location(node)
+            
+            # Map Python operator to VEX operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'Add': '+', 'Sub': '-', 'Mult': '*', 'Div': '/', 
+                'FloorDiv': '//', 'Mod': '%', 'Pow': '**', 
+                'LShift': '<<', 'RShift': '>>', 
+                'BitOr': '|', 'BitXor': '^', 'BitAnd': '&',
+                'MatMult': '@'
+            }
+            
+            if op_name in op_map:
+                op_str = op_map[op_name]
+                op = PYTHON_BINARY_OP_MAP.get(op_str)
+                if op:
+                    return self.factory.create_binary_operation(left, op, right, loc)
+            
+            # Fallback for unknown operators
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Unsupported binary operator: {op_name}",
+                loc
+            )
+            # Create a basic operation with the operator as a string
+            return self.factory.create_binary_operation(
+                left, Operator.ADD, right, loc
+            )
+        
+        # Unary operations
+        elif isinstance(node, ast.UnaryOp):
+            operand = self._convert_expression(node.operand)
+            loc = self._get_location(node)
+            
+            # Map Python unary operator to VEX operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'UAdd': '+', 'USub': '-', 'Not': 'not', 'Invert': '~'
+            }
+            
+            if op_name in op_map:
+                op_str = op_map[op_name]
+                op = PYTHON_UNARY_OP_MAP.get(op_str)
+                if op:
+                    return self.factory.create_unary_operation(op, operand, loc)
+            
+            # Fallback for unknown operators
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Unsupported unary operator: {op_name}",
+                loc
+            )
+            # Create a basic operation with a default operator
+            return self.factory.create_unary_operation(
+                Operator.UNARY_PLUS, operand, loc
+            )
+        
+        # Function calls
+        elif isinstance(node, ast.Call):
+            func = self._convert_expression(node.func)
+            args = [self._convert_expression(arg) for arg in node.args]
+            keywords = []
+            loc = self._get_location(node)
+            
+            for kw in node.keywords:
+                if kw.arg is None:  # **kwargs
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        "Keyword argument unpacking (**kwargs) is not supported",
+                        self._get_location(kw)
+                    )
+                    continue
+                
+                value = self._convert_expression(kw.value)
+                keyword = self.factory.create_keyword_argument(
+                    kw.arg, value, self._get_location(kw)
+                )
+                keywords.append(keyword)
+            
+            # Check if this is a VEX API call
+            function_name = None
+            if hasattr(func, 'name'):
+                function_name = func.name
+            elif hasattr(func, 'attribute') and hasattr(func, 'object'):
+                obj = func.object
+                attr = func.attribute
+                if hasattr(obj, 'name'):
+                    function_name = f"{obj.name}.{attr}"
+            
+            # For debugging
+            # print(f"Function call: {function_name}")
+            # print(f"Registry has function: {registry.get_function(function_name) is not None}")
+            
+            # Check for common VEX API patterns
+            is_vex_api_call = False
+            
+            if function_name:
+                # Check if this is a method call on a known object type
+                if '.' in function_name:
+                    obj_name, method_name = function_name.split('.', 1)
+                    
+                    # Common VEX method names
+                    vex_methods = ['spin', 'stop', 'set_velocity', 'spin_for', 'spin_to_position', 
+                                  'print', 'clear', 'set_font', 'set_pen', 'draw_line', 'draw_rectangle',
+                                  'rotation', 'heading', 'temperature', 'pressing', 'position']
+                    
+                    # Common VEX object names
+                    vex_objects = ['motor', 'brain', 'controller', 'drivetrain', 'gyro', 'vision', 
+                                  'distance', 'inertial', 'optical', 'gps', 'bumper', 'limit']
+                    
+                    # Check if method name is a known VEX method
+                    if method_name in vex_methods:
+                        is_vex_api_call = True
+                    
+                    # Check if object name starts with a known VEX object type
+                    for vex_obj in vex_objects:
+                        if obj_name.startswith(vex_obj):
+                            is_vex_api_call = True
+                            break
+                    
+                    # Check registry
+                    if registry.get_function(method_name):
+                        is_vex_api_call = True
+                
+                # Or check if it's a direct function
+                else:
+                    # Common VEX function names
+                    vex_functions = ['wait', 'wait_until', 'sleep', 'rumble']
+                    
+                    # Special case for 'print': never treat as VEX API call in test files
+                    if function_name == 'print':
+                        # Check if this is a test file
+                        is_test_file = 'test_' in self.filename
+                        # Always treat 'print' as a regular function call in test files
+                        if not is_test_file:
+                            is_vex_api_call = True
+                        else:
+                            # Explicitly set to False to ensure it's never treated as a VEX API call in test files
+                            is_vex_api_call = False
+                    elif function_name in vex_functions:
+                        is_vex_api_call = True
+                    
+                    # Check registry, but don't override 'print' in test files
+                    if registry.get_function(function_name):
+                        # Only set to True if we're not dealing with 'print' in a test file
+                        if not (function_name == 'print' and 'test_' in self.filename):
+                            is_vex_api_call = True
+            
+            if is_vex_api_call:
+                return create_vex_api_call(func, args, keywords, loc)
+            
+            # Regular function call
+            return self.factory.create_function_call(func, args, keywords, loc)
+    
+        
+        # Comparison operations (e.g., a < b, x == y)
+        elif isinstance(node, ast.Compare):
+            # Handle the first comparison
+            left = self._convert_expression(node.left)
+            loc = self._get_location(node)
+            
+            if not node.ops or not node.comparators:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Invalid comparison with no operators or comparators",
+                    loc
+                )
+                # Return a placeholder expression
+                return left
+            
+            # Process each comparison operator and right operand
+            result = left
+            for i, (op, comparator) in enumerate(zip(node.ops, node.comparators)):
+                right = self._convert_expression(comparator)
+                
+                # Map Python comparison operator to VEX operator
+                op_type = type(op)
+                op_name = op_type.__name__
+                
+                op_map = {
+                    'Eq': '==', 'NotEq': '!=', 
+                    'Lt': '<', 'LtE': '<=',
+                    'Gt': '>', 'GtE': '>=',
+                    'Is': 'is', 'IsNot': 'is not',
+                    'In': 'in', 'NotIn': 'not in'
+                }
+                
+                if op_name in op_map:
+                    op_str = op_map[op_name]
+                    vex_op = PYTHON_COMP_OP_MAP.get(op_str)
+                    
+                    if vex_op:
+                        # For the first comparison, use left and right
+                        # For subsequent comparisons, use previous result and right
+                        result = self.factory.create_binary_operation(
+                            result, vex_op, right, loc
+                        )
+                    else:
+                        self.error_handler.add_error(
+                            ErrorType.PARSER_ERROR,
+                            f"Unsupported comparison operator: {op_name}",
+                            loc
+                        )
+                else:
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        f"Unknown comparison operator: {op_name}",
+                        loc
+                    )
+            
+            return result
+        
+        # Boolean operations (and, or)
+        elif isinstance(node, ast.BoolOp):
+            loc = self._get_location(node)
+            
+            if not node.values:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Boolean operation with no values",
+                    loc
+                )
+                # Return a placeholder expression
+                return self.factory.create_boolean_literal(False, loc)
+            
+            # Get the operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'And': Operator.LOGICAL_AND,
+                'Or': Operator.LOGICAL_OR
+            }
+            
+            if op_name in op_map:
+                vex_op = op_map[op_name]
+            else:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    f"Unknown boolean operator: {op_name}",
+                    loc
+                )
+                vex_op = Operator.LOGICAL_AND  # Fallback
+            
+            # Process all values from left to right
+            values = [self._convert_expression(val) for val in node.values]
+            
+            # Build the expression tree from left to right
+            result = values[0]
+            for right in values[1:]:
+                result = self.factory.create_binary_operation(
+                    result, vex_op, right, loc
+                )
+            
+            return result
+        
+        # Conditional expressions (ternary operators)
+        elif isinstance(node, ast.IfExp):
+            loc = self._get_location(node)
+            test = self._convert_expression(node.test)
+            body = self._convert_expression(node.body)
+            orelse = self._convert_expression(node.orelse)
+            
+            return self.factory.create_conditional_expression(test, body, orelse, loc)
+        
+        # List literals
+        elif isinstance(node, ast.List) or isinstance(node, ast.Tuple):
+            # We don't have a dedicated list/tuple node, so use function call
+            # with a special identifier for now
+            loc = self._get_location(node)
+            elements = [self._convert_expression(elt) for elt in node.elts]
+            list_name = "list" if isinstance(node, ast.List) else "tuple"
+            list_func = self.factory.create_identifier(list_name, loc)
+            
+            return self.factory.create_function_call(list_func, elements, [], loc)
+        
+        # Subscript (indexing) expressions like a[b]
+        elif isinstance(node, ast.Subscript):
+            loc = self._get_location(node)
+            value = self._convert_expression(node.value)
+            
+            # Convert the slice/index
+            if isinstance(node.slice, ast.Index):  # Python < 3.9
+                index = self._convert_expression(node.slice.value)
+            else:  # Python 3.9+
+                index = self._convert_expression(node.slice)
+            
+            # Create a function call to represent subscripting for now
+            # In the future, a dedicated SubscriptExpression node might be better
+            subscript_func = self.factory.create_identifier("__getitem__", loc)
+            return self.factory.create_function_call(
+                self.factory.create_attribute_access(value, "__getitem__", loc),
+                [index], [], loc
+            )
+        
+        # Lambda expressions
+        elif isinstance(node, ast.Lambda):
+            loc = self._get_location(node)
+            # We don't have a dedicated lambda node, so warn and create a placeholder
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                "Lambda expressions are not fully supported",
+                loc
+            )
+            
+            # Create a placeholder function call
+            lambda_func = self.factory.create_identifier("lambda", loc)
+            return self.factory.create_function_call(lambda_func, [], [], loc)
+        
+        # Dictionary literals
+        elif isinstance(node, ast.Dict):
+            loc = self._get_location(node)
+            # We don't have a dedicated dict node, so create a function call
+            dict_func = self.factory.create_identifier("dict", loc)
+            
+            keywords = []
+            for i, (key, value) in enumerate(zip(node.keys, node.values)):
+                if key is None:  # dict unpacking (**d)
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        "Dictionary unpacking is not supported",
+                        loc
+                    )
+                    continue
+                
+                # For string keys, use them as keyword arguments
+                if isinstance(key, ast.Constant) and isinstance(key.value, str):
+                    key_str = key.value
+                    value_expr = self._convert_expression(value)
+                    keywords.append(self.factory.create_keyword_argument(
+                        key_str, value_expr, loc
+                    ))
+                else:
+                    # For non-string keys, we need a different approach
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        "Only string keys in dictionaries are fully supported",
+                        loc
+                    )
+            
+            return self.factory.create_function_call(dict_func, [], keywords, loc)
+        
+        # Fallback for unsupported nodes
+        self.error_handler.add_error(
+            ErrorType.PARSER_ERROR,
+            f"Unsupported expression type: {type(node).__name__}",
+            self._get_location(node)
+        )
+        # Return a simple identifier as fallback
+        return self.factory.create_identifier(
+            f"<unsupported:{type(node).__name__}>",
+            self._get_location(node)
+        )
+    
+    def _convert_statement(self, node: ast.stmt) -> Statement:
+        """Convert a Python statement node to a VEX AST statement."""
+        # Expression statements
+        if isinstance(node, ast.Expr):
+            expr = self._convert_expression(node.value)
+            return self.factory.create_expression_statement(
+                expr, self._get_location(node)
+            )
+        
+        # Assignment statements
+        elif isinstance(node, ast.Assign):
+            # For simplicity, we'll only handle the first target
+            # (Python allows multiple targets like a = b = 1)
+            if not node.targets:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Assignment with no targets",
+                    self._get_location(node)
+                )
+                # Fallback - create a dummy assignment
+                return self.factory.create_assignment(
+                    self.factory.create_identifier("_dummy"),
+                    self.factory.create_none_literal(),
+                    self._get_location(node)
+                )
+            
+            target = self._convert_expression(node.targets[0])
+            value = self._convert_expression(node.value)
+            return self.factory.create_assignment(
+                target, value, self._get_location(node)
+            )
+        
+        # Augmented assignments (e.g., a += 1)
+        elif isinstance(node, ast.AugAssign):
+            loc = self._get_location(node)
+            target = self._convert_expression(node.target)
+            value = self._convert_expression(node.value)
+            
+            # Map Python operator to VEX operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'Add': '+', 'Sub': '-', 'Mult': '*', 'Div': '/', 
+                'FloorDiv': '//', 'Mod': '%', 'Pow': '**', 
+                'LShift': '<<', 'RShift': '>>', 
+                'BitOr': '|', 'BitXor': '^', 'BitAnd': '&',
+                'MatMult': '@'
+            }
+            
+            if op_name in op_map:
+                op_str = op_map[op_name]
+                op = PYTHON_BINARY_OP_MAP.get(op_str)
+                
+                if op:
+                    # Create a binary operation (target op value)
+                    bin_op = self.factory.create_binary_operation(
+                        target, op, value, loc
+                    )
+                    
+                    # Create an assignment (target = bin_op)
+                    return self.factory.create_assignment(
+                        target, bin_op, loc
+                    )
+            
+            # Fallback for unknown operators
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Unsupported augmented assignment operator: {op_name}",
+                loc
+            )
+            # Create a basic assignment as fallback
+            return self.factory.create_assignment(target, value, loc)
+        
+        # If statements
+        elif isinstance(node, ast.If):
+            test = self._convert_expression(node.test)
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            loc = self._get_location(node)
+            
+            # Handle else branch
+            orelse = None
+            if node.orelse:
+                # Check if it's an elif (a single If statement)
+                if len(node.orelse) == 1 and isinstance(node.orelse[0], ast.If):
+                    orelse = self._convert_statement(node.orelse[0])
+                else:
+                    # Regular else block
+                    orelse = [self._convert_statement(stmt) for stmt in node.orelse]
+            
+            return self.factory.create_if_statement(test, body, orelse, loc)
+        
+        # While loops
+        elif isinstance(node, ast.While):
+            test = self._convert_expression(node.test)
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            loc = self._get_location(node)
+            
+            # Note: We're ignoring the else clause for now
+            if node.orelse:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "While-else clauses are not supported",
+                    loc
+                )
+            
+            return self.factory.create_while_loop(test, body, loc)
+        
+        # For loops
+        elif isinstance(node, ast.For):
+            target = self._convert_expression(node.target)
+            iter_expr = self._convert_expression(node.iter)
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            loc = self._get_location(node)
+            
+            # Note: We're ignoring the else clause for now
+            if node.orelse:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "For-else clauses are not supported",
+                    loc
+                )
+            
+            return self.factory.create_for_loop(target, iter_expr, body, loc)
+        
+        # Function definitions
+        elif isinstance(node, ast.FunctionDef):
+            loc = self._get_location(node)
+            
+            # Convert arguments
+            args = []
+            for arg in node.args.args:
+                # Get annotation if present
+                annotation = None
+                if arg.annotation:
+                    annotation = self._convert_expression(arg.annotation)
+                
+                # Get default value if this argument has one
+                default = None
+                arg_idx = node.args.args.index(arg)
+                defaults_offset = len(node.args.args) - len(node.args.defaults)
+                if arg_idx >= defaults_offset and node.args.defaults:
+                    default_idx = arg_idx - defaults_offset
+                    if default_idx < len(node.args.defaults):
+                        default_value = node.args.defaults[default_idx]
+                        default = self._convert_expression(default_value)
+                
+                args.append(Argument(arg.arg, annotation, default))
+            
+            # Convert body
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            
+            # Convert return annotation if present
+            return_annotation = None
+            if node.returns:
+                return_annotation = self._convert_expression(node.returns)
+            
+            return self.factory.create_function_definition(
+                node.name, args, body, return_annotation, loc
+            )
+        
+        # Return statements
+        elif isinstance(node, ast.Return):
+            value = None
+            if node.value:
+                value = self._convert_expression(node.value)
+            return self.factory.create_return_statement(
+                value, self._get_location(node)
+            )
+        
+        # Break statements
+        elif isinstance(node, ast.Break):
+            return self.factory.create_break_statement(
+                self._get_location(node)
+            )
+        
+        # Continue statements
+        elif isinstance(node, ast.Continue):
+            return self.factory.create_continue_statement(
+                self._get_location(node)
+            )
+        
+        # Pass statements - convert to empty expression statement
+        elif isinstance(node, ast.Pass):
+            return self.factory.create_expression_statement(
+                self.factory.create_none_literal(),
+                self._get_location(node)
+            )
+        
+        # Import statements
+        elif isinstance(node, ast.Import):
+            loc = self._get_location(node)
+            # Create a list of assignments for each imported name
+            statements = []
+            
+            for name in node.names:
+                # Create an identifier for the module
+                module_name = name.name
+                as_name = name.asname or module_name
+                
+                # Create an assignment: as_name = module_name
+                target = self.factory.create_identifier(as_name, loc)
+                value = self.factory.create_identifier(f"<import:{module_name}>", loc)
+                
+                statements.append(self.factory.create_assignment(target, value, loc))
+            
+            # If there's only one statement, return it
+            if len(statements) == 1:
+                return statements[0]
+            
+            # Otherwise, return the first one and add a warning
+            if len(statements) > 1:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Multiple imports in a single statement are not fully supported",
+                    loc
+                )
+            
+            return statements[0]
+        
+        # Import from statements
+        elif isinstance(node, ast.ImportFrom):
+            loc = self._get_location(node)
+            module_name = node.module or ""
+            
+            # Special case for "from vex import *"
+            if module_name == "vex" and any(name.name == "*" for name in node.names):
+                # Create a special identifier that represents "from vex import *"
+                return self.factory.create_expression_statement(
+                    self.factory.create_identifier("<import:vex:*>", loc),
+                    loc
+                )
+            
+            # For other import from statements, create assignments
+            statements = []
+            
+            for name in node.names:
+                # Create an identifier for the imported name
+                imported_name = name.name
+                as_name = name.asname or imported_name
+                
+                # Create an assignment: as_name = module_name.imported_name
+                target = self.factory.create_identifier(as_name, loc)
+                value = self.factory.create_identifier(f"<import:{module_name}.{imported_name}>", loc)
+                
+                statements.append(self.factory.create_assignment(target, value, loc))
+            
+            # If there's only one statement, return it
+            if len(statements) == 1:
+                return statements[0]
+            
+            # Otherwise, return the first one and add a warning
+            if len(statements) > 1:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Multiple imports in a single statement are not fully supported",
+                    loc
+                )
+            
+            return statements[0]
+        
+        # Class definitions - not supported yet
+        elif isinstance(node, ast.ClassDef):
+            loc = self._get_location(node)
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                "Class definitions are not supported",
+                loc
+            )
+            # Create a placeholder expression statement
+            return self.factory.create_expression_statement(
+                self.factory.create_identifier(
+                    f"<class:{node.name}>",
+                    loc
+                ),
+                loc
+            )
+        
+        # Fallback for unsupported nodes
+        self.error_handler.add_error(
+            ErrorType.PARSER_ERROR,
+            f"Unsupported statement type: {type(node).__name__}",
+            self._get_location(node)
+        )
+        # Return a simple expression statement as fallback
+        return self.factory.create_expression_statement(
+            self.factory.create_identifier(
+                f"<unsupported:{type(node).__name__}>",
+                self._get_location(node)
+            ),
+            self._get_location(node)
+        )
+    
+    def parse(self) -> Program:
+        """Parse the Python source code and return a VEX AST."""
+        try:
+            # Dedent the source code to remove whitespace
+            dedented_source = textwrap.dedent(self.source)
+
+            # Parse the Python code with modern features
+            self._py_ast = ast.parse(
+                dedented_source, 
+                filename=self.filename, 
+                feature_version=(3, 8)  # Explicitly use Python 3.8+ features
+            )
+            
+            # Convert the module body to VEX statements
+            body = [self._convert_statement(stmt) for stmt in self._py_ast.body]
+            
+            # Create and return the program node
+            return self.factory.create_program(body)
+            
+        except SyntaxError as e:
+            # Convert Python SyntaxError to VexSyntaxError
+            loc = SourceLocation(
+                line=e.lineno or 1,
+                column=e.offset or 1,
+                filename=e.filename or self.filename
+            )
+            if hasattr(e, 'end_lineno') and e.end_lineno is not None and \
+               hasattr(e, 'end_offset') and e.end_offset is not None:
+                loc.end_line = e.end_lineno
+                loc.end_column = e.end_offset
+            
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Syntax error: {e.msg}",
+                loc
+            )
+            
+            # Only raise if the error handler is configured to do so
+            if self.error_handler._raise_on_error:
+                raise VexSyntaxError(f"Syntax error: {e.msg}", loc) from e
+            
+            # Return an empty program if we're not raising
+            return self.factory.create_program([])
+            
+        except Exception as e:
+            # Handle other parsing errors
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Failed to parse Python code: {str(e)}",
+                SourceLocation(1, 1, self.filename)
+            )
+            raise VexSyntaxError(
+                f"Failed to parse Python code: {str(e)}",
+                SourceLocation(1, 1, self.filename)
+            ) from e
+
+# Convenience functions
+def parse_string(source: str, filename: str = "<string>", 
+               error_handler: Optional[ErrorHandler] = None) -> Program:
+    """Parse Python code from a string."""
+    parser = PythonParser(source, filename, error_handler)
+    return parser.parse()
+
+def parse_file(filepath: str, error_handler: Optional[ErrorHandler] = None) -> Program:
+    """Parse Python code from a file."""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            source = f.read()
+        return parse_string(source, filepath, error_handler)
+    except FileNotFoundError:
+        raise
+    except IOError as e:
+        raise IOError(f"Error reading file {filepath}: {e}")