vex-ast 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

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()

vex_ast/registry/functions/sensors.py

@@ -0,0 +1,195 @@
+from ..registry import registry
+from ..signature import VexFunctionSignature, VexFunctionParameter, ParameterMode, SimulationCategory
+from ...types.base import VOID, ANY
+from ...types.primitives import INT, FLOAT, BOOL
+from ...types.enums import DISTANCE_UNITS, ROTATION_UNITS, VELOCITY_UNITS
+from ...types.objects import DISTANCE, ROTATION, INERTIAL, OPTICAL, GPS
+
+def register_sensor_functions():
+    """Register sensor-related functions in the registry"""
+    
+    # Distance sensor functions
+    
+    # Distance.object_distance() method
+    object_distance_params = [
+        VexFunctionParameter("units", DISTANCE_UNITS, "MM", description="Distance units")
+    ]
+    
+    object_distance_signature = VexFunctionSignature(
+        name="object_distance",
+        return_type=FLOAT,
+        parameters=object_distance_params,
+        description="Get the distance to the detected object",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="object_distance",
+        cpp_name="objectDistance",
+        object_type=DISTANCE,
+        method_name="object_distance"
+    )
+    
+    registry.register_function(object_distance_signature)
+    
+    # Distance.is_object_detected() method
+    is_object_detected_signature = VexFunctionSignature(
+        name="is_object_detected",
+        return_type=BOOL,
+        parameters=[],
+        description="Check if an object is detected",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="is_object_detected",
+        cpp_name="isObjectDetected",
+        object_type=DISTANCE,
+        method_name="is_object_detected"
+    )
+    
+    registry.register_function(is_object_detected_signature)
+    
+    # Rotation sensor functions
+    
+    # Rotation.angle() method
+    angle_params = [
+        VexFunctionParameter("units", ROTATION_UNITS, "DEGREES", description="Rotation units")
+    ]
+    
+    angle_signature = VexFunctionSignature(
+        name="angle",
+        return_type=FLOAT,
+        parameters=angle_params,
+        description="Get the angle of the rotation sensor",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="angle",
+        cpp_name="angle",
+        object_type=ROTATION,
+        method_name="angle"
+    )
+    
+    registry.register_function(angle_signature)
+    
+    # Rotation.reset_position() method
+    reset_position_signature = VexFunctionSignature(
+        name="reset_position",
+        return_type=VOID,
+        parameters=[],
+        description="Reset the position of the rotation sensor",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="reset_position",
+        cpp_name="resetPosition",
+        object_type=ROTATION,
+        method_name="reset_position"
+    )
+    
+    registry.register_function(reset_position_signature)
+    
+    # Rotation.set_position() method
+    set_position_params = [
+        VexFunctionParameter("value", FLOAT, description="Position value to set"),
+        VexFunctionParameter("units", ROTATION_UNITS, "DEGREES", description="Rotation units")
+    ]
+    
+    set_position_signature = VexFunctionSignature(
+        name="set_position",
+        return_type=VOID,
+        parameters=set_position_params,
+        description="Set the position of the rotation sensor",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="set_position",
+        cpp_name="setPosition",
+        object_type=ROTATION,
+        method_name="set_position"
+    )
+    
+    registry.register_function(set_position_signature)
+    
+    # Rotation.velocity() method
+    velocity_params = [
+        VexFunctionParameter("units", VELOCITY_UNITS, "RPM", description="Velocity units")
+    ]
+    
+    velocity_signature = VexFunctionSignature(
+        name="velocity",
+        return_type=FLOAT,
+        parameters=velocity_params,
+        description="Get the velocity of the rotation sensor",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="velocity",
+        cpp_name="velocity",
+        object_type=ROTATION,
+        method_name="velocity"
+    )
+    
+    registry.register_function(velocity_signature)
+    
+    # Inertial sensor functions
+    
+    # Inertial.calibrate() method
+    calibrate_signature = VexFunctionSignature(
+        name="calibrate",
+        return_type=VOID,
+        parameters=[],
+        description="Calibrate the inertial sensor",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="calibrate",
+        cpp_name="calibrate",
+        object_type=INERTIAL,
+        method_name="calibrate"
+    )
+    
+    registry.register_function(calibrate_signature)
+    
+    # Inertial.is_calibrating() method
+    is_calibrating_signature = VexFunctionSignature(
+        name="is_calibrating",
+        return_type=BOOL,
+        parameters=[],
+        description="Check if the inertial sensor is calibrating",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="is_calibrating",
+        cpp_name="isCalibrating",
+        object_type=INERTIAL,
+        method_name="is_calibrating"
+    )
+    
+    registry.register_function(is_calibrating_signature)
+    
+    # Inertial.heading() method
+    heading_params = [
+        VexFunctionParameter("units", ROTATION_UNITS, "DEGREES", description="Rotation units")
+    ]
+    
+    heading_signature = VexFunctionSignature(
+        name="heading",
+        return_type=FLOAT,
+        parameters=heading_params,
+        description="Get the heading of the inertial sensor",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="heading",
+        cpp_name="heading",
+        object_type=INERTIAL,
+        method_name="heading"
+    )
+    
+    registry.register_function(heading_signature)
+    
+    # Inertial.rotation() method
+    rotation_params = [
+        VexFunctionParameter("units", ROTATION_UNITS, "DEGREES", description="Rotation units")
+    ]
+    
+    rotation_signature = VexFunctionSignature(
+        name="rotation",
+        return_type=FLOAT,
+        parameters=rotation_params,
+        description="Get the rotation of the inertial sensor",
+        category=SimulationCategory.SENSOR_READING,
+        python_name="rotation",
+        cpp_name="rotation",
+        object_type=INERTIAL,
+        method_name="rotation"
+    )
+    
+    registry.register_function(rotation_signature)
+    
+    # Add more sensor functions for other sensor types...
+
+if __name__ == "__main__":
+    register_sensor_functions()