vex-ast 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

vex_ast/__init__.py

@@ -4,13 +4,25 @@ VEX AST Generator Package.
 Provides tools for parsing VEX V5 code and generating an Abstract Syntax Tree (AST).
 """
 
+# Core functionality
 from .ast.core import Program
-from .ast.navigator import AstNavigator
 from .parser.python_parser import parse_string, parse_file
+
+# AST Navigation
+from .ast.navigator import AstNavigator, create_navigator
+
+# Visitors
 from .visitors.printer import PrintVisitor
 from .visitors.analyzer import NodeCounter, VariableCollector
-from .utils.errors import ErrorHandler, ErrorType, VexSyntaxError
-from .registry import registry_api, initialize as initialize_registry
+
+# Error handling
+from .utils.errors import ErrorHandler, ErrorType, VexSyntaxError, VexAstError, Error
+
+# Registry
+from .registry.api import registry_api
+from .registry import initialize
+
+# Serialization
 from .serialization.json_serializer import serialize_ast_to_dict, serialize_ast_to_json
 from .serialization.json_deserializer import deserialize_ast_from_dict, deserialize_ast_from_json
 from .serialization.schema import generate_ast_schema, export_schema_to_file
@@ -18,18 +30,11 @@ from .serialization.schema import generate_ast_schema, export_schema_to_file
 __version__ = "0.2.0"
 
 # Initialize the registry with default functions
-initialize_registry()
-
-def create_navigator(ast: Program) -> AstNavigator:
-    """Create an AST navigator for the given AST.
-    
-    Args:
-        ast: The AST to navigate
-        
-    Returns:
-        An AST navigator for traversing and querying the AST
-    """
-    return AstNavigator(ast)
+try:
+    initialize()
+    print("VEX function registry initialized successfully")
+except Exception as e:
+    print(f"Error initializing VEX function registry: {e}")
 
 __all__ = [
     # Core functionality
@@ -50,10 +55,12 @@ __all__ = [
     "ErrorHandler",
     "ErrorType",
     "VexSyntaxError",
+    "VexAstError",
+    "Error",
     
     # Registry
     "registry_api",
-    "initialize_registry",
+    "initialize",
     
     # Serialization
     "serialize_ast_to_dict",

vex_ast/ast/__init__.py

@@ -72,4 +72,4 @@ __all__ = [
     
     # Navigator
     'AstNavigator', 'create_navigator',
-]
+]

vex_ast/ast/navigator.py

@@ -211,3 +211,15 @@ class AstNavigator:
             if hasattr(access.object, 'name') and getattr(access.object, 'name') == object_name:
                 result.append(access)
         return result
+
+
+def create_navigator(ast_node: IAstNode) -> AstNavigator:
+    """Create a new AST navigator for the given AST node.
+    
+    Args:
+        ast_node: The AST node to navigate
+        
+    Returns:
+        A new AstNavigator instance
+    """
+    return AstNavigator(ast_node)

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/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)
@@ -205,7 +218,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/parser/__init__.py

@@ -0,0 +1,27 @@
+"""
+Parser package for VEX AST.
+
+This package provides functionality for parsing VEX code into an Abstract Syntax Tree.
+"""
+
+from .interfaces import (
+    IParser,
+    BaseParser
+)
+from .factory import NodeFactory, default_factory
+from .python_parser import parse_string, parse_file, PythonParser
+
+__all__ = [
+    # Interfaces
+    "IParser",
+    "BaseParser",
+    
+    # Factory
+    "NodeFactory",
+    "default_factory",
+    
+    # Python parser
+    "parse_string",
+    "parse_file",
+    "PythonParser"
+]

vex_ast/registry/functions/__init__.py

@@ -0,0 +1,11 @@
+"""
+Registry functions package for VEX AST.
+
+This package contains the function definitions for the VEX API registry.
+"""
+
+from .initialize import initialize_registry
+
+__all__ = [
+    "initialize_registry"
+]

vex_ast/registry/functions/display.py

@@ -0,0 +1,147 @@
+from ..registry import registry
+from ..signature import VexFunctionSignature, VexFunctionParameter, ParameterMode, SimulationCategory
+from ...types.base import VOID, ANY
+from ...types.primitives import INT, FLOAT, BOOL, STRING
+from ...types.objects import BRAIN_SCREEN, CONTROLLER
+
+def register_display_functions():
+    """Register display-related functions in the registry"""
+    
+    # Brain screen functions
+    
+    # Brain.Screen.print() method
+    print_params = [
+        VexFunctionParameter("text", ANY, description="Text to print")
+    ]
+    
+    print_signature = VexFunctionSignature(
+        name="print",
+        return_type=VOID,
+        parameters=print_params,
+        description="Print text to the brain screen",
+        category=SimulationCategory.DISPLAY_OUTPUT,
+        python_name="print",
+        cpp_name="print",
+        object_type=BRAIN_SCREEN,
+        method_name="print"
+    )
+    
+    registry.register_function(print_signature)
+    
+    # Brain.Screen.clear_screen() method
+    clear_screen_signature = VexFunctionSignature(
+        name="clear_screen",
+        return_type=VOID,
+        parameters=[],
+        description="Clear the brain screen",
+        category=SimulationCategory.DISPLAY_OUTPUT,
+        python_name="clear_screen",
+        cpp_name="clearScreen",
+        object_type=BRAIN_SCREEN,
+        method_name="clear_screen"
+    )
+    
+    registry.register_function(clear_screen_signature)
+    
+    # Brain.Screen.set_cursor() method
+    set_cursor_params = [
+        VexFunctionParameter("row", INT, description="Row position"),
+        VexFunctionParameter("col", INT, description="Column position")
+    ]
+    
+    set_cursor_signature = VexFunctionSignature(
+        name="set_cursor",
+        return_type=VOID,
+        parameters=set_cursor_params,
+        description="Set the cursor position on the brain screen",
+        category=SimulationCategory.DISPLAY_OUTPUT,
+        python_name="set_cursor",
+        cpp_name="setCursor",
+        object_type=BRAIN_SCREEN,
+        method_name="set_cursor"
+    )
+    
+    registry.register_function(set_cursor_signature)
+    
+    # Brain.Screen.draw_pixel() method
+    draw_pixel_params = [
+        VexFunctionParameter("x", INT, description="X coordinate"),
+        VexFunctionParameter("y", INT, description="Y coordinate")
+    ]
+    
+    draw_pixel_signature = VexFunctionSignature(
+        name="draw_pixel",
+        return_type=VOID,
+        parameters=draw_pixel_params,
+        description="Draw a pixel on the brain screen",
+        category=SimulationCategory.DISPLAY_OUTPUT,
+        python_name="draw_pixel",
+        cpp_name="drawPixel",
+        object_type=BRAIN_SCREEN,
+        method_name="draw_pixel"
+    )
+    
+    registry.register_function(draw_pixel_signature)
+    
+    # Brain.Screen.draw_line() method
+    draw_line_params = [
+        VexFunctionParameter("x1", INT, description="Start X coordinate"),
+        VexFunctionParameter("y1", INT, description="Start Y coordinate"),
+        VexFunctionParameter("x2", INT, description="End X coordinate"),
+        VexFunctionParameter("y2", INT, description="End Y coordinate")
+    ]
+    
+    draw_line_signature = VexFunctionSignature(
+        name="draw_line",
+        return_type=VOID,
+        parameters=draw_line_params,
+        description="Draw a line on the brain screen",
+        category=SimulationCategory.DISPLAY_OUTPUT,
+        python_name="draw_line",
+        cpp_name="drawLine",
+        object_type=BRAIN_SCREEN,
+        method_name="draw_line"
+    )
+    
+    registry.register_function(draw_line_signature)
+    
+    # Controller screen functions (V5 Controller)
+    
+    # Controller.Screen.print() method
+    controller_print_params = [
+        VexFunctionParameter("text", ANY, description="Text to print")
+    ]
+    
+    controller_print_signature = VexFunctionSignature(
+        name="print",
+        return_type=VOID,
+        parameters=controller_print_params,
+        description="Print text to the controller screen",
+        category=SimulationCategory.DISPLAY_OUTPUT,
+        python_name="print",
+        cpp_name="print",
+        object_type=CONTROLLER,
+        method_name="print"
+    )
+    
+    registry.register_function(controller_print_signature)
+    
+    # Controller.Screen.clear_screen() method
+    controller_clear_screen_signature = VexFunctionSignature(
+        name="clear_screen",
+        return_type=VOID,
+        parameters=[],
+        description="Clear the controller screen",
+        category=SimulationCategory.DISPLAY_OUTPUT,
+        python_name="clear_screen",
+        cpp_name="clearScreen",
+        object_type=CONTROLLER,
+        method_name="clear_screen"
+    )
+    
+    registry.register_function(controller_clear_screen_signature)
+    
+    # Add more display functions as needed...
+
+if __name__ == "__main__":
+    register_display_functions()

vex_ast/registry/functions/drivetrain.py

@@ -0,0 +1,163 @@
+from ..registry import registry
+from ..signature import VexFunctionSignature, VexFunctionParameter, ParameterMode, SimulationCategory
+from ...types.base import VOID
+from ...types.primitives import INT, FLOAT, BOOL
+from ...types.enums import DIRECTION_TYPE, TURN_TYPE, VELOCITY_UNITS, ROTATION_UNITS, DISTANCE_UNITS, BRAKE_TYPE
+from ...types.objects import DRIVETRAIN
+
+def register_drivetrain_functions():
+    """Register drivetrain-related functions in the registry"""
+    
+    # Drivetrain.drive() method
+    drive_params = [
+        VexFunctionParameter("direction", DIRECTION_TYPE, description="Direction to drive"),
+        VexFunctionParameter("velocity", FLOAT, 50.0, description="Velocity to drive at"),
+        VexFunctionParameter("units", VELOCITY_UNITS, "RPM", description="Velocity units")
+    ]
+    
+    drive_signature = VexFunctionSignature(
+        name="drive",
+        return_type=VOID,
+        parameters=drive_params,
+        description="Drive the drivetrain in the specified direction",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="drive",
+        cpp_name="drive",
+        object_type=DRIVETRAIN,
+        method_name="drive"
+    )
+    
+    registry.register_function(drive_signature)
+    
+    # Drivetrain.drive_for() method
+    drive_for_params = [
+        VexFunctionParameter("direction", DIRECTION_TYPE, description="Direction to drive"),
+        VexFunctionParameter("distance", FLOAT, description="Distance to drive"),
+        VexFunctionParameter("units", DISTANCE_UNITS, "INCHES", description="Distance units"),
+        VexFunctionParameter("velocity", FLOAT, 50.0, description="Velocity to drive at"),
+        VexFunctionParameter("units_v", VELOCITY_UNITS, "RPM", description="Velocity units"),
+        VexFunctionParameter("wait", BOOL, True, description="Whether to wait for completion")
+    ]
+    
+    drive_for_signature = VexFunctionSignature(
+        name="drive_for",
+        return_type=VOID,
+        parameters=drive_for_params,
+        description="Drive the drivetrain for a specific distance",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="drive_for",
+        cpp_name="driveFor",
+        object_type=DRIVETRAIN,
+        method_name="drive_for"
+    )
+    
+    registry.register_function(drive_for_signature)
+    
+    # Drivetrain.turn() method
+    turn_params = [
+        VexFunctionParameter("direction", TURN_TYPE, description="Direction to turn"),
+        VexFunctionParameter("velocity", FLOAT, 50.0, description="Velocity to turn at"),
+        VexFunctionParameter("units", VELOCITY_UNITS, "RPM", description="Velocity units")
+    ]
+    
+    turn_signature = VexFunctionSignature(
+        name="turn",
+        return_type=VOID,
+        parameters=turn_params,
+        description="Turn the drivetrain in the specified direction",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="turn",
+        cpp_name="turn",
+        object_type=DRIVETRAIN,
+        method_name="turn"
+    )
+    
+    registry.register_function(turn_signature)
+    
+    # Drivetrain.turn_for() method
+    turn_for_params = [
+        VexFunctionParameter("direction", TURN_TYPE, description="Direction to turn"),
+        VexFunctionParameter("angle", FLOAT, description="Angle to turn"),
+        VexFunctionParameter("units", ROTATION_UNITS, "DEGREES", description="Rotation units"),
+        VexFunctionParameter("velocity", FLOAT, 50.0, description="Velocity to turn at"),
+        VexFunctionParameter("units_v", VELOCITY_UNITS, "RPM", description="Velocity units"),
+        VexFunctionParameter("wait", BOOL, True, description="Whether to wait for completion")
+    ]
+    
+    turn_for_signature = VexFunctionSignature(
+        name="turn_for",
+        return_type=VOID,
+        parameters=turn_for_params,
+        description="Turn the drivetrain for a specific angle",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="turn_for",
+        cpp_name="turnFor",
+        object_type=DRIVETRAIN,
+        method_name="turn_for"
+    )
+    
+    registry.register_function(turn_for_signature)
+    
+    # Drivetrain.stop() method
+    stop_params = [
+        VexFunctionParameter("mode", BRAKE_TYPE, "COAST", description="Stopping mode (coast, brake, hold)")
+    ]
+    
+    stop_signature = VexFunctionSignature(
+        name="stop",
+        return_type=VOID,
+        parameters=stop_params,
+        description="Stop the drivetrain",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="stop",
+        cpp_name="stop",
+        object_type=DRIVETRAIN,
+        method_name="stop"
+    )
+    
+    registry.register_function(stop_signature)
+    
+    # Drivetrain.set_drive_velocity() method
+    set_drive_velocity_params = [
+        VexFunctionParameter("velocity", FLOAT, description="Velocity to set"),
+        VexFunctionParameter("units", VELOCITY_UNITS, "RPM", description="Velocity units")
+    ]
+    
+    set_drive_velocity_signature = VexFunctionSignature(
+        name="set_drive_velocity",
+        return_type=VOID,
+        parameters=set_drive_velocity_params,
+        description="Set the drive velocity of the drivetrain",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="set_drive_velocity",
+        cpp_name="setDriveVelocity",
+        object_type=DRIVETRAIN,
+        method_name="set_drive_velocity"
+    )
+    
+    registry.register_function(set_drive_velocity_signature)
+    
+    # Drivetrain.set_turn_velocity() method
+    set_turn_velocity_params = [
+        VexFunctionParameter("velocity", FLOAT, description="Velocity to set"),
+        VexFunctionParameter("units", VELOCITY_UNITS, "RPM", description="Velocity units")
+    ]
+    
+    set_turn_velocity_signature = VexFunctionSignature(
+        name="set_turn_velocity",
+        return_type=VOID,
+        parameters=set_turn_velocity_params,
+        description="Set the turn velocity of the drivetrain",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="set_turn_velocity",
+        cpp_name="setTurnVelocity",
+        object_type=DRIVETRAIN,
+        method_name="set_turn_velocity"
+    )
+    
+    registry.register_function(set_turn_velocity_signature)
+    
+    # Add more drivetrain functions as needed...
+
+if __name__ == "__main__":
+    register_drivetrain_functions()

vex_ast/registry/functions/initialize.py

@@ -0,0 +1,28 @@
+"""Initialize all VEX function definitions in the registry"""
+
+from . import motor, drivetrain, sensors, timing, display
+# Import other function modules as they are added
+
+def initialize_registry():
+    """Initialize the registry with all VEX functions"""
+    # Motor functions
+    motor.register_motor_functions()
+    
+    # Drivetrain functions
+    drivetrain.register_drivetrain_functions()
+    
+    # Sensor functions
+    sensors.register_sensor_functions()
+    
+    # Timing functions
+    timing.register_timing_functions()
+    
+    # Display functions
+    display.register_display_functions()
+    
+    # Add other function registration calls as modules are added
+    
+    print("VEX function registry initialized successfully")
+
+if __name__ == "__main__":
+    initialize_registry()

vex_ast/registry/functions/motor.py

@@ -0,0 +1,140 @@
+from ..registry import registry
+from ..signature import VexFunctionSignature, VexFunctionParameter, ParameterMode, SimulationCategory
+from ...types.base import VOID
+from ...types.primitives import INT, FLOAT, BOOL
+from ...types.enums import DIRECTION_TYPE, VELOCITY_UNITS, ROTATION_UNITS, BRAKE_TYPE
+from ...types.objects import MOTOR
+
+def register_motor_functions():
+    """Register motor-related functions in the registry"""
+    
+    # Motor.spin() method
+    spin_params = [
+        VexFunctionParameter("direction", DIRECTION_TYPE, description="Direction to spin the motor"),
+        VexFunctionParameter("velocity", FLOAT, 50.0, description="Velocity to spin at"),
+        VexFunctionParameter("units", VELOCITY_UNITS, "RPM", description="Velocity units")
+    ]
+    
+    spin_signature = VexFunctionSignature(
+        name="spin",
+        return_type=VOID,
+        parameters=spin_params,
+        description="Spin the motor in the specified direction",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="spin",
+        cpp_name="spin",
+        object_type=MOTOR,
+        method_name="spin"
+    )
+    
+    registry.register_function(spin_signature)
+    
+    # Motor.stop() method
+    stop_params = [
+        VexFunctionParameter("mode", BRAKE_TYPE, "COAST", description="Stopping mode (coast, brake, hold)")
+    ]
+    
+    stop_signature = VexFunctionSignature(
+        name="stop",
+        return_type=VOID,
+        parameters=stop_params,
+        description="Stop the motor",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="stop",
+        cpp_name="stop",
+        object_type=MOTOR,
+        method_name="stop"
+    )
+    
+    registry.register_function(stop_signature)
+    
+    # Motor.spin_to_position() method
+    spin_to_position_params = [
+        VexFunctionParameter("position", FLOAT, description="Position to spin to"),
+        VexFunctionParameter("units", ROTATION_UNITS, "DEGREES", description="Rotation units"),
+        VexFunctionParameter("velocity", FLOAT, 50.0, description="Velocity to spin at"),
+        VexFunctionParameter("units_v", VELOCITY_UNITS, "RPM", description="Velocity units"),
+        VexFunctionParameter("wait", BOOL, True, description="Whether to wait for completion")
+    ]
+    
+    spin_to_position_signature = VexFunctionSignature(
+        name="spin_to_position",
+        return_type=VOID,
+        parameters=spin_to_position_params,
+        description="Spin the motor to an absolute position",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="spin_to_position",
+        cpp_name="spinToPosition",
+        object_type=MOTOR,
+        method_name="spin_to_position"
+    )
+    
+    registry.register_function(spin_to_position_signature)
+    
+    # Motor.spin_for() method
+    spin_for_params = [
+        VexFunctionParameter("direction", DIRECTION_TYPE, description="Direction to spin"),
+        VexFunctionParameter("amount", FLOAT, description="Amount to spin"),
+        VexFunctionParameter("units", ROTATION_UNITS, "DEGREES", description="Rotation units"),
+        VexFunctionParameter("velocity", FLOAT, 50.0, description="Velocity to spin at"),
+        VexFunctionParameter("units_v", VELOCITY_UNITS, "RPM", description="Velocity units"),
+        VexFunctionParameter("wait", BOOL, True, description="Whether to wait for completion")
+    ]
+    
+    spin_for_signature = VexFunctionSignature(
+        name="spin_for",
+        return_type=VOID,
+        parameters=spin_for_params,
+        description="Spin the motor for a relative amount",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="spin_for",
+        cpp_name="spinFor",
+        object_type=MOTOR,
+        method_name="spin_for"
+    )
+    
+    registry.register_function(spin_for_signature)
+    
+    # Motor.set_velocity() method
+    set_velocity_params = [
+        VexFunctionParameter("velocity", FLOAT, description="Velocity to set"),
+        VexFunctionParameter("units", VELOCITY_UNITS, "RPM", description="Velocity units")
+    ]
+    
+    set_velocity_signature = VexFunctionSignature(
+        name="set_velocity",
+        return_type=VOID,
+        parameters=set_velocity_params,
+        description="Set the velocity of the motor",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="set_velocity",
+        cpp_name="setVelocity",
+        object_type=MOTOR,
+        method_name="set_velocity"
+    )
+    
+    registry.register_function(set_velocity_signature)
+    
+    # Motor.set_stopping() method
+    set_stopping_params = [
+        VexFunctionParameter("mode", BRAKE_TYPE, description="Stopping mode (coast, brake, hold)")
+    ]
+    
+    set_stopping_signature = VexFunctionSignature(
+        name="set_stopping",
+        return_type=VOID,
+        parameters=set_stopping_params,
+        description="Set the stopping mode of the motor",
+        category=SimulationCategory.MOTOR_CONTROL,
+        python_name="set_stopping",
+        cpp_name="setStopping",
+        object_type=MOTOR,
+        method_name="set_stopping"
+    )
+    
+    registry.register_function(set_stopping_signature)
+    
+    # Add more motor functions as needed...
+
+if __name__ == "__main__":
+    register_motor_functions()