vex-ast 0.2.2__tar.gz → 0.2.4__tar.gz

{vex_ast-0.2.2/vex_ast.egg-info → vex_ast-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vex_ast
-Version: 0.2.2
+Version: 0.2.4
 Summary: A Python package for generating Abstract Syntax Trees for VEX V5 code.
 Home-page: https://github.com/heartx2/vex_ast
 Author: Chaze

{vex_ast-0.2.2 → vex_ast-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vex_ast"
-version = "0.2.2"
+version = "0.2.4"
 description = "A Python package for generating Abstract Syntax Trees for VEX V5 code."
 readme = "README.md"
 authors = [

{vex_ast-0.2.2 → vex_ast-0.2.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='vex_ast',
-    version='0.2.2',
+    version='0.2.4',
     description='A Python package for generating Abstract Syntax Trees for VEX V5 code.',
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',

vex_ast-0.2.4/tests/test_comprehensive_integration.py

@@ -0,0 +1,338 @@
+"""
+Comprehensive integration tests for the vex_ast package.
+
+These tests ensure that all API endpoints work together correctly in various scenarios.
+"""
+
+import os
+import json
+import tempfile
+import pytest
+from typing import Dict, Any
+
+from vex_ast import (
+    parse_string,
+    parse_file,
+    ErrorHandler,
+    VexSyntaxError,
+    VexAstError,
+    PrintVisitor,
+    NodeCounter,
+    VariableCollector,
+    create_navigator,
+    serialize_ast_to_dict,
+    serialize_ast_to_json,
+    deserialize_ast_from_dict,
+    deserialize_ast_from_json,
+    generate_ast_schema,
+    export_schema_to_file,
+    registry_api
+)
+from vex_ast.ast.vex_nodes import VexAPICall
+from vex_ast.ast.validators import validate_vex_functions
+
+
+class TestComprehensiveIntegration:
+    """Comprehensive integration tests for the vex_ast package."""
+
+    def test_parse_file_functionality(self):
+        """Test the parse_file functionality with a temporary file."""
+        # Create a temporary file with VEX code
+        with tempfile.NamedTemporaryFile(mode='w+', suffix='.py', delete=False) as temp_file:
+            temp_file.write("""
+            # Define a motor
+            motor1 = Motor(PORT1)
+            
+            # Define a function
+            def move_forward(speed):
+                motor1.spin(FORWARD, speed, PERCENT)
+                wait(1, SECONDS)
+                motor1.stop()
+                return True
+            
+            # Call the function
+            success = move_forward(50)
+            """)
+            temp_file_path = temp_file.name
+        
+        try:
+            # Parse the file
+            ast = parse_file(temp_file_path)
+            
+            # Verify the AST structure
+            assert ast is not None
+            assert len(ast.body) > 0
+            
+            # Find function definitions
+            func_defs = [node for node in ast.body if node.__class__.__name__ == "FunctionDefinition"]
+            assert len(func_defs) == 1
+            assert func_defs[0].name == "move_forward"
+            
+            # Test that visitors work with the parsed AST
+            printer = PrintVisitor()
+            result = printer.visit(ast)
+            assert isinstance(result, str)
+            assert len(result) > 0
+            
+            counter = NodeCounter()
+            count = counter.visit(ast)
+            assert count > 10
+            
+            collector = VariableCollector()
+            variables = collector.visit(ast)
+            assert "motor1" in variables
+            assert "speed" in variables
+            
+        finally:
+            # Clean up the temporary file
+            os.unlink(temp_file_path)
+
+    def test_error_handling_integration(self):
+        """Test error handling integration with parsing and visitors."""
+        # Create an error handler that doesn't raise exceptions
+        error_handler = ErrorHandler(raise_on_error=False)
+        
+        # Parse code with syntax errors
+        code_with_errors = """
+        def invalid_function(
+            # Missing closing parenthesis
+            print("This will cause an error")
+        """
+        
+        # This should not raise an exception due to raise_on_error=False
+        ast = parse_string(code_with_errors, error_handler=error_handler)
+        
+        # Verify that errors were collected
+        assert error_handler.has_errors()
+        errors = error_handler.get_errors()
+        assert len(errors) > 0
+        
+        # Try with a different error handler that raises exceptions
+        error_handler_strict = ErrorHandler(raise_on_error=True)
+        
+        # This should raise a VexSyntaxError
+        with pytest.raises(VexSyntaxError):
+            parse_string(code_with_errors, error_handler=error_handler_strict)
+        
+        # Test error handling with valid code but invalid VEX API calls
+        invalid_vex_code = """
+        motor1 = Motor(PORT1)
+        # Invalid: wrong arguments to spin
+        motor1.spin(INVALID_DIRECTION, "not_a_number", "not_a_unit")
+        """
+        
+        # Parse the code (should succeed syntactically)
+        ast = parse_string(invalid_vex_code)
+        
+        # Validate VEX functions (should find errors)
+        validation_errors = validate_vex_functions(ast)
+        assert len(validation_errors) > 0
+
+    def test_end_to_end_workflow(self):
+        """Test an end-to-end workflow combining multiple API functions."""
+        # 1. Parse a complex program
+        code = """
+        # Initialize motors
+        left_motor = Motor(PORT1)
+        right_motor = Motor(PORT2)
+        
+        # Define a function to drive forward
+        def drive_forward(speed, time_ms):
+            # Set both motors to the specified speed
+            left_motor.set_velocity(speed, PERCENT)
+            right_motor.set_velocity(speed, PERCENT)
+            
+            # Start the motors
+            left_motor.spin(FORWARD)
+            right_motor.spin(FORWARD)
+            
+            # Wait for the specified time
+            wait(time_ms, MSEC)
+            
+            # Stop the motors
+            left_motor.stop()
+            right_motor.stop()
+            
+            return True
+        
+        # Define a function to turn
+        def turn(direction, speed, angle):
+            if direction == LEFT:
+                left_motor.set_velocity(-speed, PERCENT)
+                right_motor.set_velocity(speed, PERCENT)
+            else:
+                left_motor.set_velocity(speed, PERCENT)
+                right_motor.set_velocity(-speed, PERCENT)
+                
+            left_motor.spin(FORWARD)
+            right_motor.spin(FORWARD)
+            
+            # Wait until the robot has turned the specified angle
+            wait_until(gyro.rotation() >= angle)
+            
+            left_motor.stop()
+            right_motor.stop()
+            
+            return True
+        
+        # Main program
+        def main():
+            # Display welcome message
+            brain.screen.print("Robot starting...")
+            wait(1, SECONDS)
+            
+            # Drive forward at 50% speed for 2 seconds
+            success = drive_forward(50, 2000)
+            
+            if success:
+                # Turn right 90 degrees
+                turn(RIGHT, 30, 90)
+                
+                # Drive forward again
+                drive_forward(50, 1000)
+                
+                brain.screen.print("Mission completed!")
+            else:
+                brain.screen.print("Drive failed!")
+            
+            return 0
+        """
+        
+        # 2. Parse the code
+        ast = parse_string(code)
+        
+        # 3. Use a visitor to analyze the AST
+        counter = NodeCounter()
+        node_count = counter.visit(ast)
+        assert node_count > 50  # Complex program should have many nodes
+        
+        # 4. Use the navigator to find specific nodes
+        navigator = create_navigator(ast)
+        
+        # Find all function definitions
+        func_defs = navigator.find_function_definitions()
+        assert len(func_defs) == 3
+        func_names = [func.name for func in func_defs]
+        assert "drive_forward" in func_names
+        assert "turn" in func_names
+        assert "main" in func_names
+        
+        # Find all VEX API calls
+        vex_calls = navigator.find_vex_api_calls()
+        assert len(vex_calls) > 5
+        
+        # 5. Serialize the AST to JSON
+        json_str = serialize_ast_to_json(ast)
+        assert isinstance(json_str, str)
+        
+        # 6. Deserialize back to an AST
+        deserialized_ast = deserialize_ast_from_json(json_str)
+        
+        # 7. Verify the deserialized AST has the same structure
+        deserialized_func_defs = [node for node in deserialized_ast.body 
+                                 if node.__class__.__name__ == "FunctionDefinition"]
+        assert len(deserialized_func_defs) == 3
+        deserialized_func_names = [func.name for func in deserialized_func_defs]
+        assert set(deserialized_func_names) == set(func_names)
+        
+        # 8. Use a visitor on the deserialized AST
+        collector = VariableCollector()
+        variables = collector.visit(deserialized_ast)
+        assert "left_motor" in variables
+        assert "right_motor" in variables
+        assert "speed" in variables
+        assert "direction" in variables
+
+    def test_schema_export_functionality(self):
+        """Test the schema export functionality."""
+        # Generate the schema
+        schema = generate_ast_schema()
+        assert isinstance(schema, dict)
+        
+        # Export the schema to a temporary file
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as temp_file:
+            temp_file_path = temp_file.name
+        
+        try:
+            # Export the schema
+            export_schema_to_file(schema, temp_file_path)
+            
+            # Verify the file exists and contains valid JSON
+            assert os.path.exists(temp_file_path)
+            
+            with open(temp_file_path, 'r') as f:
+                loaded_schema = json.load(f)
+            
+            # Check that it's the same schema
+            assert loaded_schema["$schema"] == schema["$schema"]
+            assert "definitions" in loaded_schema
+            assert set(loaded_schema["definitions"].keys()) == set(schema["definitions"].keys())
+            
+        finally:
+            # Clean up
+            if os.path.exists(temp_file_path):
+                os.unlink(temp_file_path)
+
+    def test_edge_cases(self):
+        """Test edge cases in parsing and serialization."""
+        # Test parsing an empty program
+        empty_ast = parse_string("")
+        assert empty_ast is not None
+        assert len(empty_ast.body) == 0
+        
+        # Test parsing a program with only comments
+        comments_ast = parse_string("# This is a comment\n# Another comment")
+        assert comments_ast is not None
+        assert len(comments_ast.body) == 0
+        
+        # Test parsing a program with unusual whitespace
+        whitespace_code = """
+        
+        
+        x    =    42
+        
+        
+        y    =    x    +    10
+        
+        
+        """
+        whitespace_ast = parse_string(whitespace_code)
+        assert whitespace_ast is not None
+        assert len(whitespace_ast.body) == 2
+        
+        # Test serializing and deserializing an empty program
+        empty_json = serialize_ast_to_json(empty_ast)
+        deserialized_empty = deserialize_ast_from_json(empty_json)
+        assert deserialized_empty is not None
+        assert len(deserialized_empty.body) == 0
+        
+        # Test with a program containing all types of literals
+        literals_code = """
+        # Number literals
+        int_val = 42
+        float_val = 3.14
+        
+        # String literals
+        str_val = "Hello, world!"
+        str_val2 = 'Single quotes'
+        
+        # Boolean literals
+        bool_val1 = True
+        bool_val2 = False
+        
+        # None literal
+        none_val = None
+        """
+        
+        literals_ast = parse_string(literals_code)
+        assert literals_ast is not None
+        assert len(literals_ast.body) > 0
+        
+        # Serialize and deserialize
+        literals_json = serialize_ast_to_json(literals_ast)
+        deserialized_literals = deserialize_ast_from_json(literals_json)
+        
+        # Verify the literals were preserved
+        collector = VariableCollector()
+        variables = collector.visit(deserialized_literals)
+        assert len(variables) == 0  # All are assignments, no references

{vex_ast-0.2.2 → vex_ast-0.2.4}/tests/test_parser.py

@@ -58,9 +58,10 @@ class TestParser:
         code = "if x =="  # Incomplete if statement
         error_handler = ErrorHandler(raise_on_error=False)
         
-        with pytest.raises(VexSyntaxError):
-            parse_string(code, error_handler=error_handler)
-            
+        # Should not raise an exception when raise_on_error=False
+        ast = parse_string(code, error_handler=error_handler)
+        
+        # But should collect errors
         assert error_handler.has_errors()
         errors = error_handler.get_errors()
-        assert len(errors) >= 1
+        assert len(errors) >= 1

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/ast/expressions.py

@@ -2,7 +2,7 @@
 
 from typing import Dict, List, Optional, Union, cast, Any
 
-from .interfaces import IAstNode, IExpression, IVisitor, T_VisitorResult, IIdentifier, IFunctionCall
+from .interfaces import IAstNode, IExpression, IVisitor, T_VisitorResult, IIdentifier, IFunctionCall, IConditionalExpression
 from .core import Expression
 from .operators import Operator
 from ..utils.source_location import SourceLocation
@@ -173,6 +173,49 @@ class KeywordArgument(Expression):
         """Get the keyword value."""
         return self.value
 
+class ConditionalExpression(Expression, IConditionalExpression):
+    """A conditional expression (ternary operator, e.g., a if condition else b)."""
+    
+    _fields = ('condition', 'true_expr', 'false_expr')
+    
+    def __init__(self, condition: IExpression, true_expr: IExpression, false_expr: IExpression,
+                 location: Optional[SourceLocation] = None):
+        super().__init__(location)
+        self.condition = condition
+        self.true_expr = true_expr
+        self.false_expr = false_expr
+        
+        # Set parent references
+        if isinstance(condition, Expression):
+            condition.set_parent(self)
+        if isinstance(true_expr, Expression):
+            true_expr.set_parent(self)
+        if isinstance(false_expr, Expression):
+            false_expr.set_parent(self)
+    
+    def get_children(self) -> List[IAstNode]:
+        """Get child nodes."""
+        return [
+            cast(IAstNode, self.condition),
+            cast(IAstNode, self.true_expr),
+            cast(IAstNode, self.false_expr)
+        ]
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        return visitor.visit_conditionalexpression(self)
+    
+    def get_condition(self) -> IExpression:
+        """Get the condition expression."""
+        return self.condition
+    
+    def get_true_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is true."""
+        return self.true_expr
+    
+    def get_false_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is false."""
+        return self.false_expr
+
 class FunctionCall(Expression, IFunctionCall):
     """A function call."""
     

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/ast/interfaces.py

@@ -84,6 +84,22 @@ class IIdentifier(IExpression, Protocol):
         """Get the identifier name."""
         ...
 
+@runtime_checkable
+class IConditionalExpression(IExpression, Protocol):
+    """Protocol for conditional expression (ternary operator) nodes."""
+    
+    def get_condition(self) -> IExpression:
+        """Get the condition expression."""
+        ...
+    
+    def get_true_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is true."""
+        ...
+    
+    def get_false_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is false."""
+        ...
+
 @runtime_checkable
 class IFunctionCall(IExpression, Protocol):
     """Protocol for function call nodes."""

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/ast/vex_nodes.py

@@ -91,8 +91,21 @@ class VexAPICall(FunctionCall):
             return False, self._validation_error
         
         # Convert args and kwargs to appropriate format
-        arg_values = [arg for arg in self.args]
-        kwarg_values = {kw.name: kw.value for kw in self.keywords or []}
+        arg_values = []
+        for arg in self.args:
+            # For string literals, use their actual string value for validation
+            if hasattr(arg, 'value') and hasattr(arg, '__class__') and arg.__class__.__name__ == 'StringLiteral':
+                arg_values.append(arg.value)
+            else:
+                arg_values.append(arg)
+        
+        kwarg_values = {}
+        for kw in (self.keywords or []):
+            # For string literals, use their actual string value for validation
+            if hasattr(kw.value, 'value') and hasattr(kw.value, '__class__') and kw.value.__class__.__name__ == 'StringLiteral':
+                kwarg_values[kw.name] = kw.value.value
+            else:
+                kwarg_values[kw.name] = kw.value
         
         # Validate against the signature
         valid, error = signature.validate_arguments(arg_values, kwarg_values)

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/parser/factory.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, Optional, Type, Union, cast, List
 
 from ..ast.core import Expression, Program, Statement
 from ..ast.expressions import (
-    AttributeAccess, BinaryOperation, FunctionCall, Identifier, KeywordArgument, 
+    AttributeAccess, BinaryOperation, ConditionalExpression, FunctionCall, Identifier, KeywordArgument, 
     UnaryOperation, VariableReference
 )
 from ..ast.literals import (
@@ -77,6 +77,11 @@ class NodeFactory:
         """Create a unary operation node."""
         return UnaryOperation(op, operand, location)
     
+    def create_conditional_expression(self, condition: Expression, true_expr: Expression, false_expr: Expression,
+                                     location: Optional[SourceLocation] = None) -> ConditionalExpression:
+        """Create a conditional expression (ternary operator) node."""
+        return ConditionalExpression(condition, true_expr, false_expr, location)
+    
     def create_function_call(self, function: Expression, args: List[Expression] = None,
                              keywords: List[KeywordArgument] = None,
                              location: Optional[SourceLocation] = None) -> FunctionCall:
@@ -123,6 +128,12 @@ class NodeFactory:
         """Create a function definition node."""
         return FunctionDefinition(name, args, body, return_annotation, location)
     
+    def create_argument(self, name: str, annotation: Optional[Expression] = None,
+                       default: Optional[Expression] = None,
+                       location: Optional[SourceLocation] = None) -> Argument:
+        """Create an argument node."""
+        return Argument(name, annotation, default, location)
+    
     def create_return_statement(self, value: Optional[Expression] = None,
                                location: Optional[SourceLocation] = None) -> ReturnStatement:
         """Create a return statement node."""
@@ -176,4 +187,4 @@ class NodeFactory:
         return Program(body, location)
 
 # Global factory instance for simple use cases
-default_factory = NodeFactory()
+default_factory = NodeFactory()

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/parser/python_parser.py

@@ -294,21 +294,12 @@ class PythonParser(BaseParser):
             op_name = op_type.__name__
             
             op_map = {
-                'And': 'and',
-                'Or': 'or'
+                'And': Operator.LOGICAL_AND,
+                'Or': Operator.LOGICAL_OR
             }
             
             if op_name in op_map:
-                op_str = op_map[op_name]
-                vex_op = PYTHON_COMP_OP_MAP.get(op_str)
-                
-                if not vex_op:
-                    self.error_handler.add_error(
-                        ErrorType.PARSER_ERROR,
-                        f"Unsupported boolean operator: {op_name}",
-                        loc
-                    )
-                    vex_op = Operator.LOGICAL_AND  # Fallback
+                vex_op = op_map[op_name]
             else:
                 self.error_handler.add_error(
                     ErrorType.PARSER_ERROR,
@@ -329,6 +320,15 @@ class PythonParser(BaseParser):
             
             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
@@ -607,22 +607,77 @@ class PythonParser(BaseParser):
                 self._get_location(node)
             )
         
-        # Import statements - not fully supported yet
-        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+        # Import statements
+        elif isinstance(node, ast.Import):
             loc = self._get_location(node)
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                "Import statements are not fully supported",
-                loc
-            )
-            # Create a placeholder expression statement
-            return self.factory.create_expression_statement(
-                self.factory.create_identifier(
-                    f"<import:{getattr(node, 'names', [])}>",
+            # 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
-                ),
-                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):
@@ -692,7 +747,13 @@ class PythonParser(BaseParser):
                 f"Syntax error: {e.msg}",
                 loc
             )
-            raise VexSyntaxError(f"Syntax error: {e.msg}", loc) from e
+            
+            # 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

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/registry/signature.py

@@ -24,6 +24,11 @@ class VexFunctionParameter:
         self.description = description
         self.is_optional = default_value is not None
     
+    @property
+    def optional(self) -> bool:
+        """Alias for is_optional for compatibility."""
+        return self.is_optional
+    
     def __str__(self) -> str:
         mode_str = ""
         if self.mode == ParameterMode.REFERENCE:
@@ -138,6 +143,49 @@ class VexFunctionSignature:
             if param_name in kwargs:
                 return False, f"Duplicate argument '{param_name}' for {self.name}"
         
-        # TODO: Add type checking for arguments
+        # Type checking for arguments
+        from ..types.type_checker import type_checker
+        from ..types.enums import EnumType
+        
+        # Check positional arguments
+        for i, arg in enumerate(args):
+            if i >= len(self.parameters):
+                break
+                
+            param = self.parameters[i]
+            expected_type = param.type
+            
+            # Handle string literals for enum types
+            if isinstance(expected_type, EnumType) and isinstance(arg, str):
+                if arg not in expected_type.values:
+                    return False, f"Invalid enum value '{arg}' for parameter '{param.name}' in {self.name}"
+                continue
+                
+            # Handle other types
+            if hasattr(arg, 'get_type'):
+                arg_type = arg.get_type()
+                if arg_type and not type_checker.is_compatible(arg_type, expected_type):
+                    return False, f"Type mismatch for parameter '{param.name}' in {self.name}: expected {expected_type}, got {arg_type}"
+        
+        # Check keyword arguments
+        for kwarg_name, kwarg_value in kwargs.items():
+            # Find the parameter
+            param = next((p for p in self.parameters if p.name == kwarg_name), None)
+            if not param:
+                continue  # Already checked for unknown kwargs above
+                
+            expected_type = param.type
+            
+            # Handle string literals for enum types
+            if isinstance(expected_type, EnumType) and isinstance(kwarg_value, str):
+                if kwarg_value not in expected_type.values:
+                    return False, f"Invalid enum value '{kwarg_value}' for parameter '{param.name}' in {self.name}"
+                continue
+                
+            # Handle other types
+            if hasattr(kwarg_value, 'get_type'):
+                kwarg_type = kwarg_value.get_type()
+                if kwarg_type and not type_checker.is_compatible(kwarg_type, expected_type):
+                    return False, f"Type mismatch for parameter '{param.name}' in {self.name}: expected {expected_type}, got {kwarg_type}"
         
         return True, None

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/serialization/json_deserializer.py

@@ -10,7 +10,7 @@ from typing import Any, Dict, List, Optional, Type, Union, cast
 from ..ast.interfaces import IAstNode
 from ..parser.factory import NodeFactory
 from ..utils.source_location import SourceLocation
-from ..utils.errors import ErrorHandler
+from ..utils.errors import ErrorHandler, ErrorType
 
 
 class DeserializationFactory:
@@ -153,6 +153,7 @@ class DeserializationFactory:
             "WhileLoop": self.node_factory.create_while_loop,
             "ForLoop": self.node_factory.create_for_loop,
             "FunctionDefinition": self.node_factory.create_function_definition,
+            "Argument": self.node_factory.create_argument,
             "ReturnStatement": self.node_factory.create_return_statement,
             "BreakStatement": self.node_factory.create_break_statement,
             "ContinueStatement": self.node_factory.create_continue_statement,
@@ -198,11 +199,21 @@ class DeserializationFactory:
         except TypeError as e:
             # If the factory method doesn't accept the kwargs, report an error
             if self.error_handler:
-                self.error_handler.report_error(f"Failed to create {node_type}: {str(e)}")
+                self.error_handler.add_error(
+                    error_type=ErrorType.INTERNAL_ERROR,
+                    message=f"Failed to create {node_type}: {str(e)}"
+                )
             raise ValueError(f"Failed to deserialize {node_type}: {str(e)}")
     
     # Specific node creation methods for complex cases
     
+    def _create_attributeaccess(self, data: Dict[str, Any],
+                               location: Optional[SourceLocation]) -> IAstNode:
+        """Create an AttributeAccess node from serialized data."""
+        object_expr = self._deserialize_value(data.get("object"))
+        attribute = data.get("attribute", "")
+        return self.node_factory.create_attribute_access(object_expr, attribute, location)
+    
     def _create_program(self, data: Dict[str, Any], 
                        location: Optional[SourceLocation]) -> IAstNode:
         """Create a Program node from serialized data."""

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/serialization/schema.py

@@ -453,16 +453,15 @@ def _generate_definitions() -> Dict[str, Any]:
     return definitions
 
 
-def export_schema_to_file(filepath: str, indent: int = 2) -> None:
+def export_schema_to_file(schema: Dict[str, Any], filepath: str, indent: int = 2) -> None:
     """
-    Save the generated schema to a file.
+    Save the schema to a file.
     
     Args:
+        schema: The schema to save
         filepath: The path to save the schema to
         indent: The indentation level for pretty-printing
     """
-    schema = generate_ast_schema()
-    
     # Ensure the directory exists
     os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
     

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/utils/errors.py

@@ -50,7 +50,7 @@ class ErrorObserver(Protocol[T_Error]):
 class ErrorHandler:
     """Manages error collection and notification."""
     
-    def __init__(self, raise_on_error: bool = False):
+    def __init__(self, raise_on_error: bool = True):
         self._errors: List[Error] = []
         self._raise_on_error = raise_on_error
         self._observers: List[ErrorObserver] = []
@@ -109,4 +109,4 @@ class VexSyntaxError(VexAstError):
     
     def __init__(self, message: str, location: Optional[SourceLocation] = None):
         self.location = location
-        super().__init__(message)
+        super().__init__(message)

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/visitors/base.py

@@ -47,6 +47,9 @@ class AstVisitor(Generic[T_VisitorResult], ABC):
     def visit_unaryoperation(self, node: Any) -> T_VisitorResult:
         return self.generic_visit(node)
     
+    def visit_conditionalexpression(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
     def visit_functioncall(self, node: Any) -> T_VisitorResult:
         return self.generic_visit(node)
     
@@ -127,4 +130,4 @@ class TypedVisitorMixin:
         method_name = self.node_type_to_method_name(type(node))
         if hasattr(self, method_name):
             return getattr(self, method_name)(node)
-        return self.generic_visit(node)
+        return self.generic_visit(node)

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast/visitors/printer.py

@@ -126,6 +126,7 @@ class PrintVisitor(AstVisitor[str]):
     visit_variablereference = generic_visit
     visit_binaryoperation = generic_visit
     visit_unaryoperation = generic_visit
+    visit_conditionalexpression = generic_visit
     visit_functioncall = generic_visit
     visit_keywordargument = generic_visit
     visit_expressionstatement = generic_visit
@@ -142,4 +143,4 @@ class PrintVisitor(AstVisitor[str]):
     visit_motorcontrol = generic_visit
     visit_sensorreading = generic_visit
     visit_timingcontrol = generic_visit
-    visit_displayoutput = generic_visit
+    visit_displayoutput = generic_visit

{vex_ast-0.2.2 → vex_ast-0.2.4/vex_ast.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vex_ast
-Version: 0.2.2
+Version: 0.2.4
 Summary: A Python package for generating Abstract Syntax Trees for VEX V5 code.
 Home-page: https://github.com/heartx2/vex_ast
 Author: Chaze

{vex_ast-0.2.2 → vex_ast-0.2.4}/vex_ast.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ pytest.ini
 requirements.txt
 setup.py
 tests/conftest.py
+tests/test_comprehensive_integration.py
 tests/test_core.py
 tests/test_integration.py
 tests/test_literals.py