vex-ast 0.1.0__py3-none-any.whl

vex_ast/visitors/analyzer.py

@@ -0,0 +1,103 @@
+"""Analysis visitors for AST."""
+
+from typing import Any, Dict, List, Optional, Set
+
+from .base import AstVisitor
+from ..ast.interfaces import IAstNode
+
+class NodeCounter(AstVisitor[int]):
+    """Visitor that counts nodes in the AST."""
+    
+    def __init__(self):
+        self.count = 0
+        self.counts_by_type: Dict[str, int] = {}
+    
+    def generic_visit(self, node: IAstNode) -> int:
+        """Count this node and visit its children."""
+        self.count += 1
+        
+        # Count by node type
+        node_type = node.__class__.__name__
+        self.counts_by_type[node_type] = self.counts_by_type.get(node_type, 0) + 1
+        
+        # Visit all children
+        for child in node.get_children():
+            self.visit(child)
+        
+        return self.count
+    
+    # Implement all the required visit methods by delegating to generic_visit
+    visit_program = generic_visit
+    visit_expression = generic_visit
+    visit_statement = generic_visit
+    visit_identifier = generic_visit
+    visit_variablereference = generic_visit
+    visit_binaryoperation = generic_visit
+    visit_unaryoperation = generic_visit
+    visit_functioncall = generic_visit
+    visit_keywordargument = generic_visit
+    visit_numberliteral = generic_visit
+    visit_stringliteral = generic_visit
+    visit_booleanliteral = generic_visit
+    visit_noneliteral = generic_visit
+    visit_expressionstatement = generic_visit
+    visit_assignment = generic_visit
+    visit_ifstatement = generic_visit
+    visit_whileloop = generic_visit
+    visit_forloop = generic_visit
+    visit_functiondefinition = generic_visit
+    visit_argument = generic_visit
+    visit_returnstatement = generic_visit
+    visit_breakstatement = generic_visit
+    visit_continuestatement = generic_visit
+    visit_vexapicall = generic_visit
+    visit_motorcontrol = generic_visit
+    visit_sensorreading = generic_visit
+    visit_timingcontrol = generic_visit
+    visit_displayoutput = generic_visit
+
+class VariableCollector(AstVisitor[Set[str]]):
+    """Visitor that collects variable names used in the AST."""
+    
+    def __init__(self):
+        self.variables: Set[str] = set()
+    
+    def generic_visit(self, node: IAstNode) -> Set[str]:
+        """Collect variables from children."""
+        for child in node.get_children():
+            self.visit(child)
+        return self.variables
+    
+    def visit_variablereference(self, node: Any) -> Set[str]:
+        """Collect a variable reference."""
+        self.variables.add(node.name)
+        return self.generic_visit(node)
+    
+    # Delegate all other methods to generic_visit
+    visit_program = generic_visit
+    visit_expression = generic_visit
+    visit_statement = generic_visit
+    visit_identifier = generic_visit
+    visit_binaryoperation = generic_visit
+    visit_unaryoperation = generic_visit
+    visit_functioncall = generic_visit
+    visit_keywordargument = generic_visit
+    visit_numberliteral = generic_visit
+    visit_stringliteral = generic_visit
+    visit_booleanliteral = generic_visit
+    visit_noneliteral = generic_visit
+    visit_expressionstatement = generic_visit
+    visit_assignment = generic_visit
+    visit_ifstatement = generic_visit
+    visit_whileloop = generic_visit
+    visit_forloop = generic_visit
+    visit_functiondefinition = generic_visit
+    visit_argument = generic_visit
+    visit_returnstatement = generic_visit
+    visit_breakstatement = generic_visit
+    visit_continuestatement = generic_visit
+    visit_vexapicall = generic_visit
+    visit_motorcontrol = generic_visit
+    visit_sensorreading = generic_visit
+    visit_timingcontrol = generic_visit
+    visit_displayoutput = generic_visit

vex_ast/visitors/base.py

@@ -0,0 +1,130 @@
+"""Base visitor classes for AST traversal."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Generic, List, Optional, TypeVar, cast, Type
+
+from ..ast.interfaces import IAstNode, T_VisitorResult
+
+class AstVisitor(Generic[T_VisitorResult], ABC):
+    """Base class for AST visitors using the Visitor pattern."""
+    
+    def visit(self, node: IAstNode) -> T_VisitorResult:
+        """Visit a node by dispatching to its accept method."""
+        return node.accept(self)
+    
+    def visit_children(self, node: IAstNode) -> List[T_VisitorResult]:
+        """Visit all children of a node and return results."""
+        return [self.visit(child) for child in node.get_children()]
+    
+    @abstractmethod
+    def generic_visit(self, node: IAstNode) -> T_VisitorResult:
+        """Default visitor method for nodes without a specific method."""
+        pass
+    
+    # Required visit methods for core node types
+    def visit_program(self, node: Any) -> T_VisitorResult: 
+        return self.generic_visit(node)
+    
+    def visit_expression(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_statement(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    # Visit methods for expressions
+    def visit_identifier(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_variablereference(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_attributeaccess(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_binaryoperation(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_unaryoperation(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_functioncall(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_keywordargument(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    # Visit methods for literals
+    def visit_numberliteral(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_stringliteral(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_booleanliteral(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_noneliteral(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    # Visit methods for statements
+    def visit_expressionstatement(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_assignment(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_ifstatement(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_whileloop(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_forloop(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_functiondefinition(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_argument(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_returnstatement(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_breakstatement(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_continuestatement(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    # Visit methods for VEX-specific nodes
+    def visit_vexapicall(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_motorcontrol(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_sensorreading(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_timingcontrol(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+    
+    def visit_displayoutput(self, node: Any) -> T_VisitorResult:
+        return self.generic_visit(node)
+
+
+class TypedVisitorMixin:
+    """Mixin to provide type-specific dispatch methods."""
+    
+    @staticmethod
+    def node_type_to_method_name(node_type: Type) -> str:
+        """Convert a node type to a visitor method name."""
+        return f"visit_{node_type.__name__.lower()}"
+    
+    def dispatch_by_type(self, node: IAstNode) -> Any:
+        """Dispatch to the appropriate visit method based on the node's type."""
+        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)

vex_ast/visitors/printer.py

@@ -0,0 +1,145 @@
+"""AST printing visitor implementation."""
+
+import io
+from typing import Any, List, Optional
+
+from .base import AstVisitor
+from ..ast.interfaces import IAstNode
+
+class PrintVisitor(AstVisitor[str]):
+    """Visitor that generates a readable string representation of the AST."""
+    
+    def __init__(self):
+        self._output = io.StringIO()
+        self._indent_level = 0
+    
+    def _indent(self) -> None:
+        """Write the current indentation."""
+        self._output.write('  ' * self._indent_level)
+    
+    def _write_node_header(self, node: IAstNode, name: str) -> None:
+        """Write a standard node header with location info."""
+        self._indent()
+        self._output.write(f"{name}")
+        if node.location:
+            self._output.write(f" (at {node.location})")
+        self._output.write(":\n")
+    
+    def _format_value(self, value: Any) -> str:
+        """Format a basic value for display."""
+        return repr(value)
+    
+    def generic_visit(self, node: IAstNode) -> str:
+        """Default node visitor that displays type and attributes."""
+        node_name = node.__class__.__name__
+        self._write_node_header(node, node_name)
+        
+        # Visit fields if present
+        if hasattr(node, '_fields'):
+            self._indent_level += 1
+            for field_name in node._fields:
+                value = getattr(node, field_name, None)
+                
+                # Skip None values
+                if value is None:
+                    continue
+                
+                self._indent()
+                self._output.write(f"{field_name} = ")
+                
+                if isinstance(value, IAstNode):
+                    self._output.write("\n")
+                    self.visit(value)
+                elif isinstance(value, list):
+                    if not value:
+                        self._output.write("[]\n")
+                    else:
+                        self._output.write("[\n")
+                        self._indent_level += 1
+                        for i, item in enumerate(value):
+                            self._indent()
+                            self._output.write(f"[{i}]: ")
+                            if isinstance(item, IAstNode):
+                                self._output.write("\n")
+                                self.visit(item)
+                            else:
+                                self._output.write(f"{self._format_value(item)}\n")
+                        self._indent_level -= 1
+                        self._indent()
+                        self._output.write("]\n")
+                else:
+                    self._output.write(f"{self._format_value(value)}\n")
+            self._indent_level -= 1
+        
+        # At the root level, return the accumulated output
+        if self._indent_level == 0:
+            return self._output.getvalue()
+        return ""
+    
+    # Simple node visitors for concise output
+    def visit_identifier(self, node: Any) -> str:
+        self._output.write(f"Identifier(name={node.name!r})")
+        if node.location:
+            self._output.write(f" (at {node.location})")
+        return ""
+    
+    def visit_numberliteral(self, node: Any) -> str:
+        self._output.write(f"NumberLiteral(value={node.value!r})")
+        if node.location:
+            self._output.write(f" (at {node.location})")
+        return ""
+    
+    def visit_stringliteral(self, node: Any) -> str:
+        self._output.write(f"StringLiteral(value={node.value!r})")
+        if node.location:
+            self._output.write(f" (at {node.location})")
+        return ""
+    
+    def visit_booleanliteral(self, node: Any) -> str:
+        self._output.write(f"BooleanLiteral(value={node.value!r})")
+        if node.location:
+            self._output.write(f" (at {node.location})")
+        return ""
+    
+    def visit_noneliteral(self, node: Any) -> str:
+        self._output.write(f"NoneLiteral()")
+        if node.location:
+            self._output.write(f" (at {node.location})")
+        return ""
+    
+    # Program node is the entry point
+    def visit_program(self, node: Any) -> str:
+        self._output.write("Program:\n")
+        self._indent_level += 1
+        for i, stmt in enumerate(node.body):
+            self._indent()
+            self._output.write(f"[{i}]: \n")
+            self._indent_level += 1
+            self.visit(stmt)
+            self._indent_level -= 1
+        self._indent_level -= 1
+        return self._output.getvalue()
+    
+    # Delegate all other methods to generic_visit
+    visit_expression = generic_visit
+    visit_statement = generic_visit
+    visit_variablereference = generic_visit
+    visit_binaryoperation = generic_visit
+    visit_unaryoperation = generic_visit
+    visit_functioncall = generic_visit
+    visit_keywordargument = generic_visit
+    visit_expressionstatement = generic_visit
+    visit_assignment = generic_visit
+    visit_ifstatement = generic_visit
+    visit_whileloop = generic_visit
+    visit_forloop = generic_visit
+    visit_functiondefinition = generic_visit
+    visit_argument = generic_visit
+    visit_returnstatement = generic_visit
+    visit_breakstatement = generic_visit
+    visit_continuestatement = generic_visit
+    visit_vexapicall = generic_visit
+    visit_motorcontrol = generic_visit
+    visit_sensorreading = generic_visit
+    visit_timingcontrol = generic_visit
+    visit_displayoutput = generic_visit

vex_ast-0.1.0.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: vex_ast
+Version: 0.1.0
+Summary: A Python package for generating Abstract Syntax Trees for VEX V5 code.
+Home-page: https://github.com/teowy/vex_ast
+Author: Chaze
+Author-email: chazelexander@example.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# VEX AST Generator
+
+A Python package for generating Abstract Syntax Trees (ASTs) for VEX V5 Robot Python code.
+
+## Project Goal
+
+The primary goal of this project is to provide a robust and extensible framework for parsing VEX V5 Python code and representing it as an Abstract Syntax Tree (AST). This AST can then be used for various purposes, such as static analysis, code transformation, simulation, or integration with other development tools specific to the VEX ecosystem.
+
+## Features (Implemented)
+
+*   Parsing of standard Python syntax relevant to VEX programming.
+*   Generation of a well-defined AST structure using custom node types.
+*   Representation of core Python constructs (variables, functions, loops, conditionals, expressions).
+*   Specific AST nodes for common VEX API patterns (e.g., `MotorControl`, `SensorReading`).
+*   Visitor pattern implementation (`vex_ast.visitors`) for easy AST traversal and manipulation.
+*   Basic analysis visitors (`NodeCounter`, `VariableCollector`).
+*   AST pretty-printing visitor (`PrintVisitor`).
+*   Error handling and reporting with source location information (`vex_ast.utils`).
+*   JSON serialization and deserialization of AST nodes (`vex_ast.serialization`).
+*   JSON Schema generation for AST structure validation and documentation.
+
+## Library Structure
+
+The core library is within the `vex_ast` directory:
+
+*   `vex_ast/ast/`: Defines the structure and node types of the Abstract Syntax Tree.
+*   `vex_ast/parser/`: Contains the logic for parsing Python source code into the AST.
+*   `vex_ast/visitors/`: Provides tools for traversing and analyzing the generated AST.
+*   `vex_ast/utils/`: Includes helper modules for error handling and source location tracking.
+
+## Setup
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/yourusername/vex_ast.git # Replace with actual URL
+    cd vex_ast
+    ```
+
+2.  **Create and activate a virtual environment:**
+    ```bash
+    python3 -m venv .venv
+    source .venv/bin/activate  # On Windows use `.venv\Scripts\activate`
+    ```
+
+3.  **Install dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+4.  **(Optional) Install for development:**
+    If you plan to contribute to the project, install it in editable mode along with development dependencies:
+    ```bash
+    pip install -e .[dev]
+    ```
+
+## Usage Example
+
+### Basic Parsing and Printing
+
+```python
+from vex_ast import parse_string
+from vex_ast.visitors.printer import PrintVisitor
+
+# VEX-like Python code
+code = """
+left_motor = Motor("port1")
+right_motor = Motor("port10")
+
+def drive_forward(speed_percent):
+    left_motor.spin(FORWARD, speed_percent, PERCENT)
+    right_motor.spin(FORWARD, speed_percent, PERCENT)
+    wait(1, SECONDS)
+    left_motor.stop()
+    right_motor.stop()
+
+drive_forward(50)
+print("Movement complete!")
+"""
+
+try:
+    # Parse the code string into an AST
+    ast_tree = parse_string(code)
+
+    # Use the PrintVisitor to get a textual representation of the AST
+    printer = PrintVisitor()
+    ast_representation = printer.visit(ast_tree)
+
+    print("--- AST Representation ---")
+    print(ast_representation)
+
+except Exception as e:
+    print(f"An error occurred: {e}")
+```
+
+### Serialization and Deserialization
+
+```python
+from vex_ast import (
+    parse_string, 
+    serialize_ast_to_json, 
+    deserialize_ast_from_json,
+    export_schema_to_file
+)
+
+# Parse code into an AST
+code = "x = 10 + 20"
+ast = parse_string(code)
+
+# Serialize the AST to JSON
+json_str = serialize_ast_to_json(ast, indent=2)
+print(json_str)
+
+# Save the AST to a file
+with open("ast.json", "w") as f:
+    f.write(json_str)
+
+# Later, load the AST from JSON
+with open("ast.json", "r") as f:
+    loaded_json = f.read()
+    
+# Deserialize back to an AST object
+loaded_ast = deserialize_ast_from_json(loaded_json)
+
+# Generate and export a JSON schema
+export_schema_to_file("ast_schema.json")
+```
+
+## Development
+```bash
+Running Tests
+pytest
+```
+```bash
+Type Checking
+mypy vex_ast
+```
+```bash
+Formatting and Linting
+black vex_ast tests
+flake8 vex_ast tests
+```
+## Contributing
+
+Contributions are welcome! Please follow the established coding standards and ensure tests pass before submitting a pull request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details (You'll need to add a LICENSE file).

vex_ast-0.1.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+vex_ast/__init__.py,sha256=YPsS_1ab9-G3WYmyxQobDA1U8y5KJkj2qxm_p_s9Oow,1724
+vex_ast/ast/__init__.py,sha256=3ZtTiNeBPWOYgNWmxThn0h7UQx8Z0bHbK6hRHCUuILQ,2435
+vex_ast/ast/core.py,sha256=q-15q5VfGIVPAmFsSiWeFAZ55MPsXfCRa21rrt2hmlM,2670
+vex_ast/ast/expressions.py,sha256=b0cDs239wvygCIL9s0W8uuyuPeMZz3DwxQ0wmBta_XM,7758
+vex_ast/ast/interfaces.py,sha256=DXKdAzts0EBWjCRgYkz_kVSMcYbNIyPdwYpTr7c6P2A,5928
+vex_ast/ast/literals.py,sha256=PXbOH5Y2fxEngWk_FOiFsx3PC2SEqcx0bcfOGJ3SdbI,2618
+vex_ast/ast/navigator.py,sha256=2ELYIWTZNuaJHLMDiY9bbRkz8XAEDRnPNN8uKRafNYg,7253
+vex_ast/ast/operators.py,sha256=I-yWvhsrz-OxmBZs5zIss_GTZF5S-nwcSmIzvAVtddM,3160
+vex_ast/ast/statements.py,sha256=OWRthjYGmTuNozYAHjh_Enp5t-hR1PphtPnFg31FeWw,11841
+vex_ast/ast/validators.py,sha256=lhEm1dt-nzMiaUan_AWEOm0NiwXN7wYNkLCl1c3drqc,4455
+vex_ast/ast/vex_nodes.py,sha256=kVil-ApFIeZ_BoeqYppfVRPSTg1KFUOcvt1vCE6QRgs,10148
+vex_ast/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vex_ast/parser/factory.py,sha256=gaje0jOPu5lpndgX9c3VuQ_q-FJuFz9yC5y2bD69lL4,8770
+vex_ast/parser/interfaces.py,sha256=Ttc0bD_5X420ZCT9MLUf_wE1aZLWLkaJRQqCwBy9wIs,956
+vex_ast/parser/python_parser.py,sha256=e1owk-c6Rb4Bt5SYcgB-urZzqsX5xC9tzcK1sB8gkr4,29687
+vex_ast/parser/strategies.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vex_ast/registry/__init__.py,sha256=dXT8OS7uLyBSdQKZDWrtbANzgSWcg9HUQDA1EaLOvjQ,1188
+vex_ast/registry/api.py,sha256=yyW-TsCIULTzePAoyMvEqD_RNlkFSb4PLpiSkw6ueQk,5460
+vex_ast/registry/categories.py,sha256=y5tnCzHQ9PPg9hOzOMgyE1ZAhcsjgeFSrgqdJrdqHEg,4885
+vex_ast/registry/language_map.py,sha256=eekN3k-K9g90GFi4--If3nfJCyarUJxDWDCDvLm7mdU,2656
+vex_ast/registry/registry.py,sha256=gvsQKyeXWp84T2uDB4O_WQgKCeq8W9udl8TD5MnPZzc,6661
+vex_ast/registry/signature.py,sha256=m8gQKdc5IaORDdfdBX6_qH1OL5LoTzveGoWlIIaOES0,5763
+vex_ast/registry/simulation_behavior.py,sha256=WwkVKae0owtv3WTrfnVH93rpsh9lbqJ_RSAVmpIVA_k,313
+vex_ast/registry/validation.py,sha256=xq5UjSWYAcRxjxsCGg3WU5RtPN-DB-JAqKqDNGvnJGk,1973
+vex_ast/serialization/__init__.py,sha256=qPTEiMjU8hpVxNH5z4MY7Yj60AxuFurjXZStjhWWf6o,835
+vex_ast/serialization/json_deserializer.py,sha256=m_xiEUEoFXGfFylK3M8BVs7F2EieQJ9wbUa_ZTpkHtQ,10523
+vex_ast/serialization/json_serializer.py,sha256=YvMRUpqXjtbxlIvathEIywUqbH3Ne6GSRODfFB0QCGM,4465
+vex_ast/serialization/schema.py,sha256=zpKujT7u3Qw2kNbwjV09lNzeQAsCxvMx-uAdaRMEstA,14431
+vex_ast/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vex_ast/utils/errors.py,sha256=uq_jyu-YasifXjKSpPbVxup-XFf0XSHmp7A0Zd87TUY,3850
+vex_ast/utils/source_location.py,sha256=r857ypqUBqex2y_R0RzZo7pz5di9qtEeWFFQ4HwzYQE,1297
+vex_ast/utils/type_definitions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vex_ast/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vex_ast/visitors/analyzer.py,sha256=cBT5PRbtfQ_Dt1qiHN-wdO5KnC2yl-Ul5RasXg9geHY,3668
+vex_ast/visitors/base.py,sha256=Ph0taTIVMHV_QjXfDd0ipZnCXVJErkyRtPpfwfzo-kY,4859
+vex_ast/visitors/printer.py,sha256=CUY_73hxm7MoC-63JeIXaVYnZ8QqtfMqbek2R2HMEmE,5411
+vex_ast/visitors/transformer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vex_ast-0.1.0.dist-info/METADATA,sha256=A7JHuJeTux45tRPBF9772gQNdp36fVqv2v_Zc_WZ-Zs,5327
+vex_ast-0.1.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+vex_ast-0.1.0.dist-info/top_level.txt,sha256=MoZGrpKgNUDiqL9gWp4q3wMw3q93XPEEjmBNPJQcNAs,8
+vex_ast-0.1.0.dist-info/RECORD,,

vex_ast-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vex_ast-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vex_ast