vex-ast 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

vex_ast/types/enums.py

@@ -1,122 +1,122 @@
-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
-})
-
-# Port type enum
-PORT_TYPE = EnumType("PortType", {
-    "PORT1": 1,
-    "PORT2": 2,
-    "PORT3": 3,
-    "PORT4": 4,
-    "PORT5": 5,
-    "PORT6": 6,
-    "PORT7": 7,
-    "PORT8": 8,
-    "PORT9": 9,
-    "PORT10": 10,
-    "PORT11": 11,
-    "PORT12": 12,
-    "PORT13": 13,
-    "PORT14": 14,
-    "PORT15": 15,
-    "PORT16": 16,
-    "PORT17": 17,
-    "PORT18": 18,
-    "PORT19": 19,
-    "PORT20": 20,
-    "PORT21": 21
-})
-
-# Add more VEX enum types as needed
+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
+})
+
+# Port type enum
+PORT_TYPE = EnumType("PortType", {
+    "PORT1": 1,
+    "PORT2": 2,
+    "PORT3": 3,
+    "PORT4": 4,
+    "PORT5": 5,
+    "PORT6": 6,
+    "PORT7": 7,
+    "PORT8": 8,
+    "PORT9": 9,
+    "PORT10": 10,
+    "PORT11": 11,
+    "PORT12": 12,
+    "PORT13": 13,
+    "PORT14": 14,
+    "PORT15": 15,
+    "PORT16": 16,
+    "PORT17": 17,
+    "PORT18": 18,
+    "PORT19": 19,
+    "PORT20": 20,
+    "PORT21": 21
+})
+
+# Add more VEX enum types as needed

vex_ast/types/objects.py

@@ -1,64 +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
+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

vex_ast/types/primitives.py

@@ -1,69 +1,69 @@
-from typing import Optional, Union, List, Set, Dict, Any
-from .base import VexType, type_registry
-
-class PrimitiveType(VexType):
-    """Base class for primitive types like int, float, string, etc."""
-    
-    def __init__(self, name: str):
-        self._name = name
-        type_registry.register_type(self)
-    
-    @property
-    def name(self) -> str:
-        return self._name
-    
-    def __str__(self) -> str:
-        return self._name
-
-class NumericType(PrimitiveType):
-    """Base class for numeric types"""
-    
-    def is_compatible_with(self, other: VexType) -> bool:
-        """Numeric types are compatible with other numeric types"""
-        return isinstance(other, NumericType)
-
-class IntegerType(NumericType):
-    """Integer type"""
-    
-    def __init__(self):
-        super().__init__("int")
-    
-    def is_compatible_with(self, other: VexType) -> bool:
-        """Integers are compatible with numeric types"""
-        return isinstance(other, NumericType)
-
-class FloatType(NumericType):
-    """Float type"""
-    
-    def __init__(self):
-        super().__init__("float")
-    
-    def is_compatible_with(self, other: VexType) -> bool:
-        """Floats are compatible with numeric types"""
-        return isinstance(other, NumericType)
-
-class BooleanType(PrimitiveType):
-    """Boolean type"""
-    
-    def __init__(self):
-        super().__init__("bool")
-    
-    def is_compatible_with(self, other: VexType) -> bool:
-        """Booleans are only compatible with booleans"""
-        return isinstance(other, BooleanType)
-
-class StringType(PrimitiveType):
-    """String type"""
-    
-    def __init__(self):
-        super().__init__("string")
-    
-    def is_compatible_with(self, other: VexType) -> bool:
-        """Strings are only compatible with strings"""
-        return isinstance(other, StringType)
-
-# Singleton instances
-INT = IntegerType()
-FLOAT = FloatType()
-BOOL = BooleanType()
+from typing import Optional, Union, List, Set, Dict, Any
+from .base import VexType, type_registry
+
+class PrimitiveType(VexType):
+    """Base class for primitive types like int, float, string, etc."""
+    
+    def __init__(self, name: str):
+        self._name = name
+        type_registry.register_type(self)
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    def __str__(self) -> str:
+        return self._name
+
+class NumericType(PrimitiveType):
+    """Base class for numeric types"""
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        """Numeric types are compatible with other numeric types"""
+        return isinstance(other, NumericType)
+
+class IntegerType(NumericType):
+    """Integer type"""
+    
+    def __init__(self):
+        super().__init__("int")
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        """Integers are compatible with numeric types"""
+        return isinstance(other, NumericType)
+
+class FloatType(NumericType):
+    """Float type"""
+    
+    def __init__(self):
+        super().__init__("float")
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        """Floats are compatible with numeric types"""
+        return isinstance(other, NumericType)
+
+class BooleanType(PrimitiveType):
+    """Boolean type"""
+    
+    def __init__(self):
+        super().__init__("bool")
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        """Booleans are only compatible with booleans"""
+        return isinstance(other, BooleanType)
+
+class StringType(PrimitiveType):
+    """String type"""
+    
+    def __init__(self):
+        super().__init__("string")
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        """Strings are only compatible with strings"""
+        return isinstance(other, StringType)
+
+# Singleton instances
+INT = IntegerType()
+FLOAT = FloatType()
+BOOL = BooleanType()
 STRING = StringType()

vex_ast/types/type_checker.py

@@ -1,32 +1,32 @@
-from typing import Optional, Any, List, Dict, Union, Tuple
-from .base import VexType, ANY
-from .primitives import INT, FLOAT, BOOL, STRING
-
-class TypeChecker:
-    """Utility for checking type compatibility"""
-    
-    def is_compatible(self, value_type: VexType, expected_type: VexType) -> bool:
-        """Check if value_type is compatible with expected_type"""
-        # Any type is compatible with anything
-        if expected_type == ANY:
-            return True
-            
-        return value_type.is_compatible_with(expected_type)
-    
-    def get_python_type(self, value: Any) -> Optional[VexType]:
-        """Convert a Python value to a VEX type"""
-        if value is None:
-            return None
-        if isinstance(value, bool):
-            return BOOL
-        if isinstance(value, int):
-            return INT
-        if isinstance(value, float):
-            return FLOAT
-        if isinstance(value, str):
-            return STRING
-        # Complex objects would need additional mapping logic
-        return None
-
-# Singleton instance
+from typing import Optional, Any, List, Dict, Union, Tuple
+from .base import VexType, ANY
+from .primitives import INT, FLOAT, BOOL, STRING
+
+class TypeChecker:
+    """Utility for checking type compatibility"""
+    
+    def is_compatible(self, value_type: VexType, expected_type: VexType) -> bool:
+        """Check if value_type is compatible with expected_type"""
+        # Any type is compatible with anything
+        if expected_type == ANY:
+            return True
+            
+        return value_type.is_compatible_with(expected_type)
+    
+    def get_python_type(self, value: Any) -> Optional[VexType]:
+        """Convert a Python value to a VEX type"""
+        if value is None:
+            return None
+        if isinstance(value, bool):
+            return BOOL
+        if isinstance(value, int):
+            return INT
+        if isinstance(value, float):
+            return FLOAT
+        if isinstance(value, str):
+            return STRING
+        # Complex objects would need additional mapping logic
+        return None
+
+# Singleton instance
 type_checker = TypeChecker()

vex_ast/utils/README.md

@@ -1,39 +1,39 @@
-Utilities (vex_ast.utils)
-
-This directory contains utility modules that provide supporting functionality for the VEX AST parser and other components.
-
-Purpose
-
-These modules encapsulate common tasks and data structures needed across the vex_ast package, promoting code reuse and separation of concerns.
-
-Modules
-
-Error Handling (errors.py):
-
-ErrorType: An enum defining categories of errors (e.g., PARSER_ERROR, SEMANTIC_ERROR).
-
-Error: A class representing a single error instance, containing the type, message, optional source location, and optional suggestion.
-
-ErrorHandler: A central class for collecting and managing errors encountered during parsing or AST processing. It allows registering observers and can optionally raise exceptions immediately upon error detection.
-
-VexAstError, VexSyntaxError: Custom exception classes for AST-related errors, with VexSyntaxError specifically for parsing issues.
-
-Importance: Provides a robust way to handle and report problems found in the source code or during AST processing, crucial for user feedback and debugging.
-
-Source Location (source_location.py):
-
-SourceLocation: A dataclass representing a position or span within the original source code file. It includes line and column numbers (and optionally end line/column and filename).
-
-Importance: Allows AST nodes and errors to be linked back to their origin in the source code, which is essential for accurate error reporting, debugging tools, and source mapping.
-
-Usage
-
-These utilities are primarily used internally by other parts of the vex_ast package:
-
-The PythonParser uses the ErrorHandler to report syntax errors or issues during AST conversion. It uses SourceLocation to tag generated AST nodes with their origin.
-
-AST Node classes store SourceLocation objects.
-
-Visitors might use the ErrorHandler if they perform analysis that detects semantic errors.
-
-Error messages often include the string representation of a SourceLocation.
+Utilities (vex_ast.utils)
+
+This directory contains utility modules that provide supporting functionality for the VEX AST parser and other components.
+
+Purpose
+
+These modules encapsulate common tasks and data structures needed across the vex_ast package, promoting code reuse and separation of concerns.
+
+Modules
+
+Error Handling (errors.py):
+
+ErrorType: An enum defining categories of errors (e.g., PARSER_ERROR, SEMANTIC_ERROR).
+
+Error: A class representing a single error instance, containing the type, message, optional source location, and optional suggestion.
+
+ErrorHandler: A central class for collecting and managing errors encountered during parsing or AST processing. It allows registering observers and can optionally raise exceptions immediately upon error detection.
+
+VexAstError, VexSyntaxError: Custom exception classes for AST-related errors, with VexSyntaxError specifically for parsing issues.
+
+Importance: Provides a robust way to handle and report problems found in the source code or during AST processing, crucial for user feedback and debugging.
+
+Source Location (source_location.py):
+
+SourceLocation: A dataclass representing a position or span within the original source code file. It includes line and column numbers (and optionally end line/column and filename).
+
+Importance: Allows AST nodes and errors to be linked back to their origin in the source code, which is essential for accurate error reporting, debugging tools, and source mapping.
+
+Usage
+
+These utilities are primarily used internally by other parts of the vex_ast package:
+
+The PythonParser uses the ErrorHandler to report syntax errors or issues during AST conversion. It uses SourceLocation to tag generated AST nodes with their origin.
+
+AST Node classes store SourceLocation objects.
+
+Visitors might use the ErrorHandler if they perform analysis that detects semantic errors.
+
+Error messages often include the string representation of a SourceLocation.