vex-ast 0.2.1__tar.gz → 0.2.3__tar.gz

{vex_ast-0.2.1/vex_ast.egg-info → vex_ast-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vex_ast
-Version: 0.2.1
+Version: 0.2.3
 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.1 → vex_ast-0.2.3}/pyproject.toml

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

{vex_ast-0.2.1 → vex_ast-0.2.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='vex_ast',
-    version='0.2.1',
+    version='0.2.3',
     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.3/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.1 → vex_ast-0.2.3}/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.1 → vex_ast-0.2.3}/vex_ast/__init__.py

@@ -30,7 +30,11 @@ from .serialization.schema import generate_ast_schema, export_schema_to_file
 __version__ = "0.2.0"
 
 # Initialize the registry with default functions
-initialize()
+try:
+    initialize()
+    print("VEX function registry initialized successfully")
+except Exception as e:
+    print(f"Error initializing VEX function registry: {e}")
 
 __all__ = [
     # Core functionality
@@ -65,4 +69,4 @@ __all__ = [
     "deserialize_ast_from_json",
     "generate_ast_schema",
     "export_schema_to_file"
-]
+]

{vex_ast-0.2.1 → vex_ast-0.2.3}/vex_ast/ast/validators.py

@@ -81,11 +81,17 @@ class VexFunctionValidator(AstVisitor[List[Tuple[VexAPICall, str]]]):
                 # Check if this is a method call on a known object type
                 if '.' in function_name:
                     obj_name, method_name = function_name.split('.', 1)
-                    # For method calls, we need to check if the method exists for any object type
-                    # since we don't know the actual type of the object at validation time
-                    # Just check if the method name exists in the registry API
+                    
+                    # First check if the method exists in the registry
                     if registry_api.get_function(method_name):
                         is_vex_function = True
+                    else:
+                        # Try to check if it's a method on any known object type
+                        from ..types.objects import MOTOR, TIMER, BRAIN, CONTROLLER
+                        for obj_type in [MOTOR, TIMER, BRAIN, CONTROLLER]:
+                            if registry_api.get_method(obj_type, method_name):
+                                is_vex_function = True
+                                break
                 # Or check if it's a direct function
                 elif registry_api.get_function(function_name):
                     is_vex_function = True

{vex_ast-0.2.1 → vex_ast-0.2.3}/vex_ast/ast/vex_nodes.py

@@ -59,7 +59,20 @@ class VexAPICall(FunctionCall):
         if '.' in function_name:
             # For method calls like "motor1.spin", extract the method name
             obj_name, method_name = function_name.split('.', 1)
+            
+            # First try to get the method signature directly
             self._signature = registry_api.get_function(method_name)
+            
+            # If that fails, try to get it as a method of a specific object type
+            # This is a fallback since we don't know the actual type at parse time
+            if not self._signature:
+                # Try common object types
+                from ..types.objects import MOTOR, TIMER, BRAIN, CONTROLLER
+                for obj_type in [MOTOR, TIMER, BRAIN, CONTROLLER]:
+                    method_sig = registry_api.get_method(obj_type, method_name)
+                    if method_sig:
+                        self._signature = method_sig
+                        break
         else:
             # For direct function calls
             self._signature = registry_api.get_function(function_name)
@@ -78,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)
@@ -205,7 +231,19 @@ def create_vex_api_call(function: IExpression, args: List[IExpression],
     if '.' in function_name:
         # For method calls like "motor1.spin", extract the method name
         obj_name, method_name = function_name.split('.', 1)
+        
+        # First try to get the method signature directly
         signature = registry_api.get_function(method_name)
+        
+        # If that fails, try to get it as a method of a specific object type
+        if not signature:
+            # Try common object types
+            from ..types.objects import MOTOR, TIMER, BRAIN, CONTROLLER
+            for obj_type in [MOTOR, TIMER, BRAIN, CONTROLLER]:
+                method_sig = registry_api.get_method(obj_type, method_name)
+                if method_sig:
+                    signature = method_sig
+                    break
     else:
         # For direct function calls
         signature = registry_api.get_function(function_name)

{vex_ast-0.2.1 → vex_ast-0.2.3}/vex_ast/parser/factory.py

@@ -123,6 +123,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 +182,4 @@ class NodeFactory:
         return Program(body, location)
 
 # Global factory instance for simple use cases
-default_factory = NodeFactory()
+default_factory = NodeFactory()

{vex_ast-0.2.1 → vex_ast-0.2.3}/vex_ast/parser/python_parser.py

@@ -692,7 +692,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.1 → vex_ast-0.2.3}/vex_ast/registry/signature.py

@@ -138,6 +138,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.1 → vex_ast-0.2.3}/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.1 → vex_ast-0.2.3}/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.1 → vex_ast-0.2.3}/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.1 → vex_ast-0.2.3/vex_ast.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vex_ast
-Version: 0.2.1
+Version: 0.2.3
 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.1 → vex_ast-0.2.3}/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