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

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

vex_ast/registry/functions/timing.py

@@ -0,0 +1,104 @@
+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 TIME_UNITS
+from ...types.objects import TIMER
+
+def register_timing_functions():
+    """Register timing-related functions in the registry"""
+    
+    # Global wait function
+    wait_params = [
+        VexFunctionParameter("time", FLOAT, description="Time to wait"),
+        VexFunctionParameter("units", TIME_UNITS, "MSEC", description="Time units")
+    ]
+    
+    wait_signature = VexFunctionSignature(
+        name="wait",
+        return_type=VOID,
+        parameters=wait_params,
+        description="Wait for a specified amount of time",
+        category=SimulationCategory.TIMING_CONTROL,
+        python_name="wait",
+        cpp_name="wait"
+    )
+    
+    registry.register_function(wait_signature)
+    
+    # Timer functions
+    
+    # Timer.time() method
+    time_params = [
+        VexFunctionParameter("units", TIME_UNITS, "MSEC", description="Time units")
+    ]
+    
+    time_signature = VexFunctionSignature(
+        name="time",
+        return_type=FLOAT,
+        parameters=time_params,
+        description="Get the current time of the timer",
+        category=SimulationCategory.TIMING_CONTROL,
+        python_name="time",
+        cpp_name="time",
+        object_type=TIMER,
+        method_name="time"
+    )
+    
+    registry.register_function(time_signature)
+    
+    # Timer.clear() method
+    clear_signature = VexFunctionSignature(
+        name="clear",
+        return_type=VOID,
+        parameters=[],
+        description="Clear the timer",
+        category=SimulationCategory.TIMING_CONTROL,
+        python_name="clear",
+        cpp_name="clear",
+        object_type=TIMER,
+        method_name="clear"
+    )
+    
+    registry.register_function(clear_signature)
+    
+    # Timer.reset() method
+    reset_signature = VexFunctionSignature(
+        name="reset",
+        return_type=VOID,
+        parameters=[],
+        description="Reset the timer",
+        category=SimulationCategory.TIMING_CONTROL,
+        python_name="reset",
+        cpp_name="reset",
+        object_type=TIMER,
+        method_name="reset"
+    )
+    
+    registry.register_function(reset_signature)
+    
+    # Timer.event() method
+    event_params = [
+        VexFunctionParameter("callback", ANY, description="Callback function to execute"),
+        VexFunctionParameter("delay", FLOAT, description="Time delay before callback execution"),
+        VexFunctionParameter("units", TIME_UNITS, "MSEC", description="Time units")
+    ]
+    
+    event_signature = VexFunctionSignature(
+        name="event",
+        return_type=VOID,
+        parameters=event_params,
+        description="Register a callback function to be called after a delay",
+        category=SimulationCategory.EVENT_HANDLING,
+        python_name="event",
+        cpp_name="event",
+        object_type=TIMER,
+        method_name="event"
+    )
+    
+    registry.register_function(event_signature)
+    
+    # Add more timing functions as needed...
+
+if __name__ == "__main__":
+    register_timing_functions()

vex_ast/types/__init__.py

@@ -0,0 +1,140 @@
+"""
+Types package for VEX AST.
+
+This package provides type definitions and type checking functionality for VEX AST.
+"""
+
+from .base import (
+    VexType,
+    VoidType,
+    AnyType,
+    TypeRegistry,
+    VOID,
+    ANY,
+    type_registry
+)
+
+from .primitives import (
+    PrimitiveType,
+    IntegerType,
+    FloatType,
+    BooleanType,
+    StringType,
+    INT,
+    FLOAT,
+    BOOL,
+    STRING
+)
+
+from .objects import (
+    ObjectType,
+    MOTOR,
+    MOTOR_GROUP,
+    DRIVETRAIN,
+    BRAIN,
+    CONTROLLER,
+    INERTIAL,
+    DISTANCE,
+    ROTATION,
+    OPTICAL,
+    GPS,
+    ELECTROMAGNETIC,
+    BRAIN_BATTERY,
+    BRAIN_SCREEN,
+    BRAIN_LCD,
+    COMPETITION,
+    TIMER,
+    BUMPER,
+    LIMIT_SWITCH,
+    ENCODER,
+    SONAR,
+    GYRO,
+    PNEUMATIC,
+    VISION
+)
+
+from .enums import (
+    EnumType,
+    DIRECTION_TYPE,
+    TURN_TYPE,
+    BRAKE_TYPE,
+    VELOCITY_UNITS,
+    ROTATION_UNITS,
+    TIME_UNITS,
+    DISTANCE_UNITS,
+    CURRENT_UNITS,
+    TORQUE_UNITS,
+    TEMPERATURE_UNITS,
+    ANALOG_UNITS
+)
+
+from .type_checker import (
+    TypeChecker,
+    type_checker as check_type_compatibility
+)
+
+__all__ = [
+    # Base types
+    "VexType",
+    "VoidType",
+    "AnyType",
+    "TypeRegistry",
+    "VOID",
+    "ANY",
+    "type_registry",
+    
+    # Primitive types
+    "PrimitiveType",
+    "IntegerType",
+    "FloatType",
+    "BooleanType",
+    "StringType",
+    "INT",
+    "FLOAT",
+    "BOOL",
+    "STRING",
+    
+    # Object types
+    "ObjectType",
+    "MOTOR",
+    "MOTOR_GROUP",
+    "DRIVETRAIN",
+    "BRAIN",
+    "CONTROLLER",
+    "INERTIAL",
+    "DISTANCE",
+    "ROTATION",
+    "OPTICAL",
+    "GPS",
+    "ELECTROMAGNETIC",
+    "BRAIN_BATTERY",
+    "BRAIN_SCREEN",
+    "BRAIN_LCD",
+    "COMPETITION",
+    "TIMER",
+    "BUMPER",
+    "LIMIT_SWITCH",
+    "ENCODER",
+    "SONAR",
+    "GYRO",
+    "PNEUMATIC",
+    "VISION",
+    
+    # Enum types
+    "EnumType",
+    "DIRECTION_TYPE",
+    "TURN_TYPE",
+    "BRAKE_TYPE",
+    "VELOCITY_UNITS",
+    "ROTATION_UNITS",
+    "TIME_UNITS",
+    "DISTANCE_UNITS",
+    "CURRENT_UNITS",
+    "TORQUE_UNITS",
+    "TEMPERATURE_UNITS",
+    "ANALOG_UNITS",
+    
+    # Type checking
+    "TypeChecker",
+    "check_type_compatibility"
+]

vex_ast/types/base.py

@@ -0,0 +1,84 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Union, List, Type, Set, TypeVar, Generic
+
+class VexType(ABC):
+    """Base abstract class for all VEX types"""
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the canonical name of this type"""
+        pass
+    
+    @abstractmethod
+    def is_compatible_with(self, other: 'VexType') -> bool:
+        """Check if this type is compatible with another type"""
+        pass
+    
+    @abstractmethod
+    def __str__(self) -> str:
+        """String representation of the type"""
+        pass
+    
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, VexType):
+            return False
+        return self.name == other.name
+
+class VoidType(VexType):
+    """Represents the void type (no return value)"""
+    
+    @property
+    def name(self) -> str:
+        return "void"
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        return isinstance(other, VoidType)
+    
+    def __str__(self) -> str:
+        return "void"
+
+class AnyType(VexType):
+    """Represents any type (for generic functions)"""
+    
+    @property
+    def name(self) -> str:
+        return "any"
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        return True  # Any type is compatible with all types
+    
+    def __str__(self) -> str:
+        return "any"
+
+class TypeRegistry:
+    """Global registry of types to ensure type uniqueness"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(TypeRegistry, cls).__new__(cls)
+            cls._instance._types = {}
+        return cls._instance
+    
+    def register_type(self, type_: VexType) -> None:
+        """Register a type in the registry"""
+        self._types[type_.name] = type_
+    
+    def get_type(self, name: str) -> Optional[VexType]:
+        """Get a type by name"""
+        return self._types.get(name)
+    
+    def get_all_types(self) -> List[VexType]:
+        """Get all registered types"""
+        return list(self._types.values())
+
+# Singleton instances
+VOID = VoidType()
+ANY = AnyType()
+
+# Global registry
+type_registry = TypeRegistry()
+type_registry.register_type(VOID)
+type_registry.register_type(ANY)

vex_ast/types/enums.py

@@ -0,0 +1,97 @@
+from typing import Dict, List, Any, Optional, Set
+from .base import VexType, type_registry
+from .primitives import StringType, IntegerType, INT
+
+class EnumType(VexType):
+    """Represents a VEX enum type"""
+    
+    def __init__(self, name: str, values: Dict[str, Any] = None):
+        self._name = name
+        self._values = values or {}
+        type_registry.register_type(self)
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @property
+    def values(self) -> Dict[str, Any]:
+        return self._values.copy()
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        """Enums are compatible with themselves or with integers"""
+        return isinstance(other, EnumType) and self.name == other.name or isinstance(other, IntegerType)
+    
+    def __str__(self) -> str:
+        return f"enum {self._name}"
+    
+    def add_value(self, name: str, value: Any) -> None:
+        """Add a value to the enum"""
+        self._values[name] = value
+    
+    def is_valid_value(self, value: Any) -> bool:
+        """Check if a value is valid for this enum"""
+        return value in self._values.values() or value in self._values
+
+# Create VEX enum types
+DIRECTION_TYPE = EnumType("DirectionType", {
+    "FORWARD": 0,
+    "REVERSE": 1
+})
+
+TURN_TYPE = EnumType("TurnType", {
+    "LEFT": 0,
+    "RIGHT": 1
+})
+
+BRAKE_TYPE = EnumType("BrakeType", {
+    "COAST": 0,
+    "BRAKE": 1,
+    "HOLD": 2
+})
+
+VELOCITY_UNITS = EnumType("VelocityUnits", {
+    "PCT": 0,       # Percentage
+    "RPM": 1,       # Revolutions per minute
+    "DPS": 2        # Degrees per second
+})
+
+ROTATION_UNITS = EnumType("RotationUnits", {
+    "DEG": 0,       # Degrees
+    "REV": 1,       # Revolutions
+    "RAW": 2        # Raw data
+})
+
+TIME_UNITS = EnumType("TimeUnits", {
+    "SEC": 0,       # Seconds
+    "MSEC": 1       # Milliseconds
+})
+
+DISTANCE_UNITS = EnumType("DistanceUnits", {
+    "MM": 0,        # Millimeters
+    "IN": 1         # Inches
+})
+
+CURRENT_UNITS = EnumType("CurrentUnits", {
+    "AMP": 0        # Amperes
+})
+
+TORQUE_UNITS = EnumType("TorqueUnits", {
+    "NM": 0,        # Newton meters
+    "INLB": 1       # Inch pounds
+})
+
+TEMPERATURE_UNITS = EnumType("TemperatureUnits", {
+    "CELSIUS": 0,
+    "FAHRENHEIT": 1
+})
+
+ANALOG_UNITS = EnumType("AnalogUnits", {
+    "PCT": 0,       # Percentage
+    "EIGHTBIT": 1,  # 8-bit (0-255)
+    "TENBIT": 2,    # 10-bit (0-1023)
+    "TWELVEBIT": 3, # 12-bit (0-4095)
+    "MV": 4         # Millivolts
+})
+
+# Add more VEX enum types as needed

vex_ast/types/objects.py

@@ -0,0 +1,64 @@
+from typing import Optional, List, Dict, Any, Set, TYPE_CHECKING
+from .base import VexType, type_registry
+
+# Use TYPE_CHECKING to avoid circular imports
+if TYPE_CHECKING:
+    from ..registry.signature import VexFunctionSignature
+
+class ObjectType(VexType):
+    """Base class for all VEX object types (motors, sensors, etc.)"""
+    
+    def __init__(self, name: str, methods: Dict[str, 'VexFunctionSignature'] = None):
+        self._name = name
+        self._methods = methods or {}
+        type_registry.register_type(self)
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @property
+    def methods(self) -> Dict[str, Any]:  # Use Any instead of forward reference
+        return self._methods
+    
+    def add_method(self, method_name: str, signature: Any) -> None:  # Use Any instead of forward reference
+        """Add a method to this object type"""
+        self._methods[method_name] = signature
+    
+    def get_method(self, method_name: str) -> Optional[Any]:  # Use Any instead of forward reference
+        """Get a method by name"""
+        return self._methods.get(method_name)
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        """Objects are compatible only with the same type"""
+        return isinstance(other, ObjectType) and self.name == other.name
+    
+    def __str__(self) -> str:
+        return self._name
+
+# VEX object types - define basic types here, methods will be added later
+MOTOR = ObjectType("Motor")
+MOTOR_GROUP = ObjectType("MotorGroup")
+DRIVETRAIN = ObjectType("Drivetrain")
+BRAIN = ObjectType("Brain")
+CONTROLLER = ObjectType("Controller")
+INERTIAL = ObjectType("Inertial")
+DISTANCE = ObjectType("Distance")
+ROTATION = ObjectType("Rotation")
+OPTICAL = ObjectType("Optical")
+GPS = ObjectType("GPS")
+ELECTROMAGNETIC = ObjectType("Electromagnetic")
+BRAIN_BATTERY = ObjectType("BrainBattery")
+BRAIN_SCREEN = ObjectType("BrainScreen")
+BRAIN_LCD = ObjectType("BrainLcd")
+COMPETITION = ObjectType("Competition")
+TIMER = ObjectType("Timer")
+BUMPER = ObjectType("Bumper")
+LIMIT_SWITCH = ObjectType("LimitSwitch")
+ENCODER = ObjectType("Encoder")
+SONAR = ObjectType("Sonar")
+GYRO = ObjectType("Gyro")
+PNEUMATIC = ObjectType("Pneumatic")
+VISION = ObjectType("Vision")
+
+# Add additional object types as needed