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

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

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

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

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

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

@@ -2,7 +2,7 @@
 
 from typing import Dict, List, Optional, Union, cast, Any
 
-from .interfaces import IAstNode, IExpression, IVisitor, T_VisitorResult, IIdentifier, IFunctionCall
+from .interfaces import IAstNode, IExpression, IVisitor, T_VisitorResult, IIdentifier, IFunctionCall, IConditionalExpression
 from .core import Expression
 from .operators import Operator
 from ..utils.source_location import SourceLocation
@@ -173,6 +173,49 @@ class KeywordArgument(Expression):
         """Get the keyword value."""
         return self.value
 
+class ConditionalExpression(Expression, IConditionalExpression):
+    """A conditional expression (ternary operator, e.g., a if condition else b)."""
+    
+    _fields = ('condition', 'true_expr', 'false_expr')
+    
+    def __init__(self, condition: IExpression, true_expr: IExpression, false_expr: IExpression,
+                 location: Optional[SourceLocation] = None):
+        super().__init__(location)
+        self.condition = condition
+        self.true_expr = true_expr
+        self.false_expr = false_expr
+        
+        # Set parent references
+        if isinstance(condition, Expression):
+            condition.set_parent(self)
+        if isinstance(true_expr, Expression):
+            true_expr.set_parent(self)
+        if isinstance(false_expr, Expression):
+            false_expr.set_parent(self)
+    
+    def get_children(self) -> List[IAstNode]:
+        """Get child nodes."""
+        return [
+            cast(IAstNode, self.condition),
+            cast(IAstNode, self.true_expr),
+            cast(IAstNode, self.false_expr)
+        ]
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        return visitor.visit_conditionalexpression(self)
+    
+    def get_condition(self) -> IExpression:
+        """Get the condition expression."""
+        return self.condition
+    
+    def get_true_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is true."""
+        return self.true_expr
+    
+    def get_false_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is false."""
+        return self.false_expr
+
 class FunctionCall(Expression, IFunctionCall):
     """A function call."""
     

{vex_ast-0.2.3 → vex_ast-0.2.4}/vex_ast/ast/interfaces.py

@@ -84,6 +84,22 @@ class IIdentifier(IExpression, Protocol):
         """Get the identifier name."""
         ...
 
+@runtime_checkable
+class IConditionalExpression(IExpression, Protocol):
+    """Protocol for conditional expression (ternary operator) nodes."""
+    
+    def get_condition(self) -> IExpression:
+        """Get the condition expression."""
+        ...
+    
+    def get_true_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is true."""
+        ...
+    
+    def get_false_expression(self) -> IExpression:
+        """Get the expression to evaluate if condition is false."""
+        ...
+
 @runtime_checkable
 class IFunctionCall(IExpression, Protocol):
     """Protocol for function call nodes."""

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

@@ -4,7 +4,7 @@ from typing import Any, Dict, Optional, Type, Union, cast, List
 
 from ..ast.core import Expression, Program, Statement
 from ..ast.expressions import (
-    AttributeAccess, BinaryOperation, FunctionCall, Identifier, KeywordArgument, 
+    AttributeAccess, BinaryOperation, ConditionalExpression, FunctionCall, Identifier, KeywordArgument, 
     UnaryOperation, VariableReference
 )
 from ..ast.literals import (
@@ -77,6 +77,11 @@ class NodeFactory:
         """Create a unary operation node."""
         return UnaryOperation(op, operand, location)
     
+    def create_conditional_expression(self, condition: Expression, true_expr: Expression, false_expr: Expression,
+                                     location: Optional[SourceLocation] = None) -> ConditionalExpression:
+        """Create a conditional expression (ternary operator) node."""
+        return ConditionalExpression(condition, true_expr, false_expr, location)
+    
     def create_function_call(self, function: Expression, args: List[Expression] = None,
                              keywords: List[KeywordArgument] = None,
                              location: Optional[SourceLocation] = None) -> FunctionCall:

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

@@ -294,21 +294,12 @@ class PythonParser(BaseParser):
             op_name = op_type.__name__
             
             op_map = {
-                'And': 'and',
-                'Or': 'or'
+                'And': Operator.LOGICAL_AND,
+                'Or': Operator.LOGICAL_OR
             }
             
             if op_name in op_map:
-                op_str = op_map[op_name]
-                vex_op = PYTHON_COMP_OP_MAP.get(op_str)
-                
-                if not vex_op:
-                    self.error_handler.add_error(
-                        ErrorType.PARSER_ERROR,
-                        f"Unsupported boolean operator: {op_name}",
-                        loc
-                    )
-                    vex_op = Operator.LOGICAL_AND  # Fallback
+                vex_op = op_map[op_name]
             else:
                 self.error_handler.add_error(
                     ErrorType.PARSER_ERROR,
@@ -329,6 +320,15 @@ class PythonParser(BaseParser):
             
             return result
         
+        # Conditional expressions (ternary operators)
+        elif isinstance(node, ast.IfExp):
+            loc = self._get_location(node)
+            test = self._convert_expression(node.test)
+            body = self._convert_expression(node.body)
+            orelse = self._convert_expression(node.orelse)
+            
+            return self.factory.create_conditional_expression(test, body, orelse, loc)
+        
         # List literals
         elif isinstance(node, ast.List) or isinstance(node, ast.Tuple):
             # We don't have a dedicated list/tuple node, so use function call
@@ -607,22 +607,77 @@ class PythonParser(BaseParser):
                 self._get_location(node)
             )
         
-        # Import statements - not fully supported yet
-        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+        # Import statements
+        elif isinstance(node, ast.Import):
             loc = self._get_location(node)
-            self.error_handler.add_error(
-                ErrorType.PARSER_ERROR,
-                "Import statements are not fully supported",
-                loc
-            )
-            # Create a placeholder expression statement
-            return self.factory.create_expression_statement(
-                self.factory.create_identifier(
-                    f"<import:{getattr(node, 'names', [])}>",
+            # Create a list of assignments for each imported name
+            statements = []
+            
+            for name in node.names:
+                # Create an identifier for the module
+                module_name = name.name
+                as_name = name.asname or module_name
+                
+                # Create an assignment: as_name = module_name
+                target = self.factory.create_identifier(as_name, loc)
+                value = self.factory.create_identifier(f"<import:{module_name}>", loc)
+                
+                statements.append(self.factory.create_assignment(target, value, loc))
+            
+            # If there's only one statement, return it
+            if len(statements) == 1:
+                return statements[0]
+            
+            # Otherwise, return the first one and add a warning
+            if len(statements) > 1:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Multiple imports in a single statement are not fully supported",
                     loc
-                ),
-                loc
-            )
+                )
+            
+            return statements[0]
+        
+        # Import from statements
+        elif isinstance(node, ast.ImportFrom):
+            loc = self._get_location(node)
+            module_name = node.module or ""
+            
+            # Special case for "from vex import *"
+            if module_name == "vex" and any(name.name == "*" for name in node.names):
+                # Create a special identifier that represents "from vex import *"
+                return self.factory.create_expression_statement(
+                    self.factory.create_identifier("<import:vex:*>", loc),
+                    loc
+                )
+            
+            # For other import from statements, create assignments
+            statements = []
+            
+            for name in node.names:
+                # Create an identifier for the imported name
+                imported_name = name.name
+                as_name = name.asname or imported_name
+                
+                # Create an assignment: as_name = module_name.imported_name
+                target = self.factory.create_identifier(as_name, loc)
+                value = self.factory.create_identifier(f"<import:{module_name}.{imported_name}>", loc)
+                
+                statements.append(self.factory.create_assignment(target, value, loc))
+            
+            # If there's only one statement, return it
+            if len(statements) == 1:
+                return statements[0]
+            
+            # Otherwise, return the first one and add a warning
+            if len(statements) > 1:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Multiple imports in a single statement are not fully supported",
+                    loc
+                )
+            
+            return statements[0]
         
         # Class definitions - not supported yet
         elif isinstance(node, ast.ClassDef):

{vex_ast-0.2.3 → vex_ast-0.2.4}/vex_ast/registry/signature.py

@@ -24,6 +24,11 @@ class VexFunctionParameter:
         self.description = description
         self.is_optional = default_value is not None
     
+    @property
+    def optional(self) -> bool:
+        """Alias for is_optional for compatibility."""
+        return self.is_optional
+    
     def __str__(self) -> str:
         mode_str = ""
         if self.mode == ParameterMode.REFERENCE:

{vex_ast-0.2.3 → vex_ast-0.2.4}/vex_ast/visitors/base.py

@@ -47,6 +47,9 @@ class AstVisitor(Generic[T_VisitorResult], ABC):
     def visit_unaryoperation(self, node: Any) -> T_VisitorResult:
         return self.generic_visit(node)
     
+    def visit_conditionalexpression(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
     def visit_functioncall(self, node: Any) -> T_VisitorResult:
         return self.generic_visit(node)
     
@@ -127,4 +130,4 @@ class TypedVisitorMixin:
         method_name = self.node_type_to_method_name(type(node))
         if hasattr(self, method_name):
             return getattr(self, method_name)(node)
-        return self.generic_visit(node)
+        return self.generic_visit(node)

{vex_ast-0.2.3 → vex_ast-0.2.4}/vex_ast/visitors/printer.py

@@ -126,6 +126,7 @@ class PrintVisitor(AstVisitor[str]):
     visit_variablereference = generic_visit
     visit_binaryoperation = generic_visit
     visit_unaryoperation = generic_visit
+    visit_conditionalexpression = generic_visit
     visit_functioncall = generic_visit
     visit_keywordargument = generic_visit
     visit_expressionstatement = generic_visit
@@ -142,4 +143,4 @@ class PrintVisitor(AstVisitor[str]):
     visit_motorcontrol = generic_visit
     visit_sensorreading = generic_visit
     visit_timingcontrol = generic_visit
-    visit_displayoutput = generic_visit
+    visit_displayoutput = generic_visit

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vex_ast
-Version: 0.2.3
+Version: 0.2.4
 Summary: A Python package for generating Abstract Syntax Trees for VEX V5 code.
 Home-page: https://github.com/heartx2/vex_ast
 Author: Chaze