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

vex_ast/README.md

@@ -0,0 +1,51 @@
+VEX AST Package (vex_ast)
+
+This directory is the root of the vex_ast Python package. It orchestrates the different components of the VEX AST generation and processing system.
+
+Purpose
+
+The vex_ast package provides a unified interface for parsing VEX V5 Python code into an Abstract Syntax Tree (AST) and tools for working with that AST.
+
+Structure
+
+The package is organized into several sub-packages:
+
+ast/: Contains the definitions for all AST node types, representing the structure of the parsed code. See vex_ast/ast/README.md.
+
+parser/: Includes the parsing logic responsible for converting source code text into an AST instance. See vex_ast/parser/README.md.
+
+visitors/: Provides implementations of the Visitor pattern for traversing, analyzing, or transforming the AST. See vex_ast/visitors/README.md.
+
+utils/: Contains utility classes and functions, primarily for error handling and source location tracking. See vex_ast/utils/README.md.
+
+Core Exports
+
+The main components are exposed through the vex_ast/__init__.py file, making them easily accessible:
+
+parse_string(source, ...): Parses Python code from a string.
+
+parse_file(filepath, ...): Parses Python code from a file.
+
+Program: The root node type of the generated AST.
+
+PrintVisitor: A visitor to generate a string representation of the AST.
+
+NodeCounter: A visitor to count nodes in the AST.
+
+VariableCollector: A visitor to collect variable names used in the AST.
+
+ErrorHandler: Class for managing errors during parsing and processing.
+
+VexSyntaxError, VexAstError: Custom exception types.
+
+Workflow
+
+The typical workflow involves:
+
+Using parse_string or parse_file from this package to generate an AST (Program object) from source code.
+
+Instantiating one or more visitors from vex_ast.visitors (or custom ones).
+
+Calling the visit method of the visitor with the root Program node to perform analysis, transformation, or other operations on the AST.
+
+Using the ErrorHandler to manage and inspect any errors encountered during the process.

vex_ast/READMEAPI.md

@@ -0,0 +1,318 @@
+# VEX AST (`vex_ast`) - Public API Reference
+
+This document describes the main functions and classes exposed by the `vex_ast` package, intended for users who want to parse VEX V5 Python code and interact with the resulting Abstract Syntax Tree (AST).
+
+## Overview
+
+The core workflow typically involves:
+
+1.  Parsing source code (from a string or file) using `parse_string` or `parse_file`. This requires an optional `ErrorHandler` instance.
+2.  Receiving a `Program` object, which is the root of the generated AST.
+3.  Instantiating one or more `AstVisitor` subclasses (like `PrintVisitor`, `NodeCounter`, `VariableCollector`, or custom ones).
+4.  Calling the visitor's `visit()` method with the `Program` node to traverse the AST and perform actions.
+5.  Checking the `ErrorHandler` instance for any reported errors during parsing or visiting.
+
+---
+
+## Parsing Functions
+
+These functions are the entry points for converting source code into an AST.
+
+### `parse_string`
+
+Parses VEX V5 Python code provided as a string.
+
+**Signature:**
+
+```python
+def parse_string(
+    source: str,
+    filename: str = "<string>",
+    error_handler: Optional[ErrorHandler] = None
+) -> Program:
+
+
+Arguments:
+
+source (str): The string containing the Python code to parse.
+
+filename (str, optional): The name to associate with the source code, used in error messages and source locations. Defaults to "<string>".
+
+error_handler (Optional[ErrorHandler], optional): An instance of ErrorHandler to collect parsing errors. If None, a default ErrorHandler is created internally (which will raise VexSyntaxError on the first syntax error). It's recommended to provide your own handler to manage errors more flexibly.
+
+Returns:
+
+Program: The root node of the generated Abstract Syntax Tree.
+
+Raises:
+
+VexSyntaxError: If a syntax error is encountered during parsing and the error_handler is configured to raise errors immediately (or if no handler is provided).
+
+VexAstError: For other internal parsing or AST conversion issues if the error_handler is configured to raise errors.
+
+parse_file
+
+Parses VEX V5 Python code read from a specified file.
+
+Signature:
+
+def parse_file(
+    filepath: str,
+    error_handler: Optional[ErrorHandler] = None
+) -> Program:
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+
+Arguments:
+
+filepath (str): The path to the Python file to be parsed.
+
+error_handler (Optional[ErrorHandler], optional): An instance of ErrorHandler to collect parsing errors. See parse_string for details.
+
+Returns:
+
+Program: The root node of the generated Abstract Syntax Tree.
+
+Raises:
+
+FileNotFoundError: If the specified filepath does not exist.
+
+IOError: If there is an error reading the file.
+
+VexSyntaxError: If a syntax error is encountered (see parse_string).
+
+VexAstError: For other internal parsing errors (see parse_string).
+
+Core AST Node
+Program
+
+Represents the root node of the entire Abstract Syntax Tree.
+
+Description:
+
+The Program node is the object returned by parse_string and parse_file. It serves as the entry point for traversing the AST using visitors.
+
+Key Attribute:
+
+body (List[IStatement]): A list containing the top-level statements (like function definitions, assignments, expression statements) found in the parsed code.
+
+Usage:
+
+You typically don't instantiate Program directly. You receive it from a parsing function and pass it to the visit() method of an AstVisitor.
+
+ast_root: Program = parse_string("x = 1")
+printer = PrintVisitor()
+printer.visit(ast_root) # Pass the Program node to the visitor
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+Standard Visitors
+
+Visitors provide mechanisms to traverse and process the AST. You instantiate a visitor and then call its visit method on an AST node (usually the Program root).
+
+PrintVisitor
+
+Generates a formatted, indented string representation of the AST structure. Useful for debugging and inspection.
+
+Instantiation:
+
+printer = PrintVisitor()
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+
+Core Method:
+
+visit(node: IAstNode) -> str: Traverses the AST starting from node (typically the Program root) and returns a multi-line string representing the tree.
+
+Example:
+
+ast_root = parse_string("y = a + 5")
+visitor = PrintVisitor()
+ast_string_representation = visitor.visit(ast_root)
+print(ast_string_representation)
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+NodeCounter
+
+Counts the number of nodes in the AST.
+
+Instantiation:
+
+counter = NodeCounter()
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+
+Core Method:
+
+visit(node: IAstNode) -> int: Traverses the AST starting from node and returns the total count of nodes visited.
+
+Additional Attribute:
+
+counts_by_type (Dict[str, int]): After calling visit, this dictionary holds the counts for each specific node type encountered (e.g., {'Assignment': 1, 'BinaryOperation': 1, ...}).
+
+Example:
+
+ast_root = parse_string("def f():\n  return 10")
+visitor = NodeCounter()
+total_nodes = visitor.visit(ast_root)
+print(f"Total nodes: {total_nodes}")
+print(f"Nodes by type: {visitor.counts_by_type}")
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+VariableCollector
+
+Collects the names of all variables referenced (read from) in the AST. Does not include variables only assigned to or function/class names being defined.
+
+Instantiation:
+
+collector = VariableCollector()
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+
+Core Method:
+
+visit(node: IAstNode) -> Set[str]: Traverses the AST starting from node and returns a set containing the names of all referenced variables (identifiers used in a Load context).
+
+Example:
+
+code = """
+x = 10
+y = x + z
+def my_func(p):
+    q = p
+"""
+ast_root = parse_string(code)
+visitor = VariableCollector()
+referenced_vars = visitor.visit(ast_root)
+print(f"Referenced variables: {referenced_vars}") # Output: {'x', 'z', 'p'}
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+Error Handling
+
+Components for managing and reporting errors during parsing and processing.
+
+ErrorHandler
+
+Manages the collection and reporting of errors.
+
+Instantiation:
+
+# Option 1: Collect errors, don't raise exceptions immediately
+handler = ErrorHandler(raise_on_error=False)
+
+# Option 2: Raise VexSyntaxError/VexAstError on the first error
+handler = ErrorHandler(raise_on_error=True) # Default behavior if omitted
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+
+Key Methods:
+
+get_errors() -> List[Error]: Returns a list of all Error objects collected so far.
+
+has_errors() -> bool: Returns True if any errors have been collected, False otherwise. Useful after parsing with raise_on_error=False.
+
+clear_errors() -> None: Removes all collected errors.
+
+add_observer(observer: ErrorObserver) -> None: (Advanced) Registers a custom object to be notified whenever an error is added.
+
+remove_observer(observer: ErrorObserver) -> None: (Advanced) Unregisters an observer.
+
+Usage:
+
+Typically, you create an ErrorHandler instance and pass it to parse_string or parse_file.
+
+error_handler = ErrorHandler(raise_on_error=False)
+try:
+    ast = parse_string("x = 1 + ", error_handler=error_handler)
+    if error_handler.has_errors():
+        print("Parsing completed with non-fatal errors:")
+        for err in error_handler.get_errors():
+            print(f"- {err}")
+    else:
+        print("Parsing successful.")
+        # Proceed with AST processing...
+except VexAstError as e:
+     # This shouldn't happen if raise_on_error=False, but good practice
+     print(f"Unexpected VexAstError: {e}")
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+Python
+IGNORE_WHEN_COPYING_END
+ErrorType
+
+An Enum used within Error objects to categorize the type of error.
+
+Values:
+
+LEXER_ERROR
+
+PARSER_ERROR
+
+TYPE_ERROR
+
+SEMANTIC_ERROR
+
+INTERNAL_ERROR
+
+Usage:
+
+You typically check the error_type attribute of Error objects retrieved from ErrorHandler.get_errors().
+
+VexSyntaxError
+
+Exception raised specifically for syntax errors encountered during parsing when the ErrorHandler is configured to raise errors.
+
+Inheritance: VexSyntaxError -> VexAstError -> Exception
+
+Attribute:
+
+location (Optional[SourceLocation]): May contain the location (line, column) where the syntax error occurred.
+
+VexAstError
+
+The base exception class for all errors originating from the vex_ast library. VexSyntaxError is a subclass.
+
+This reference covers the main components needed to use the vex_ast library effectively for parsing and basic AST interaction. For more advanced use cases, you might need to delve into the specific AST node types in vex_ast.ast or create custom visitors inheriting from vex_ast.visitors.AstVisitor.
+
+IGNORE_WHEN_COPYING_START
+content_copy
+download
+Use code with caution.
+IGNORE_WHEN_COPYING_END

vex_ast/ast/README.md

@@ -0,0 +1,87 @@
+AST Node Definitions (vex_ast.ast)
+
+This directory defines the structure and types of nodes used in the Abstract Syntax Tree (AST) representation of VEX V5 Python code.
+
+Purpose
+
+The AST provides a structured, hierarchical representation of the source code, abstracting away the specific syntax details. This structure is the foundation for analysis, transformation, and interpretation of the code.
+
+Core Concepts
+
+Interfaces (interfaces.py): Defines the fundamental protocols (IAstNode, IExpression, IStatement, ILiteral, IVisitor) that all nodes and visitors adhere to. This ensures a consistent structure.
+
+Base Classes (core.py): Provides abstract base classes (AstNode, Expression, Statement) that implement common functionality like location tracking and the basic accept method for the Visitor pattern. Program is the root node type.
+
+Visitor Pattern: Each node implements an accept(visitor) method, allowing external IVisitor objects to operate on the AST without modifying the node classes themselves.
+
+Child Nodes: Each node provides a get_children() method to facilitate traversal of the tree.
+
+Source Location: Nodes can store optional SourceLocation information (from vex_ast.utils) linking them back to the original code.
+
+Node Categories
+
+The AST nodes are organized into logical categories:
+
+Expressions (expressions.py): Represent code constructs that evaluate to a value.
+
+Identifier: Variable names, function names.
+
+VariableReference: Usage of a variable.
+
+AttributeAccess: Accessing attributes (e.g., motor.spin).
+
+BinaryOperation: Operations like +, -, *, /, ==, and, or.
+
+UnaryOperation: Operations like - (negation), not.
+
+FunctionCall: Calling functions or methods.
+
+KeywordArgument: Named arguments in function calls (e.g., speed=50).
+
+Literals (literals.py): Represent constant values.
+
+NumberLiteral: Integers and floats.
+
+StringLiteral: Text strings.
+
+BooleanLiteral: True or False.
+
+NoneLiteral: The None value.
+
+Statements (statements.py): Represent actions or control flow constructs.
+
+ExpressionStatement: An expression used on its own line (e.g., a function call).
+
+Assignment: Assigning a value to a variable (=).
+
+IfStatement: Conditional execution (if/elif/else).
+
+WhileLoop: Looping based on a condition.
+
+ForLoop: Iterating over a sequence.
+
+FunctionDefinition: Defining a function (def).
+
+Argument: Parameters in a function definition.
+
+ReturnStatement: Returning a value from a function.
+
+BreakStatement, ContinueStatement: Loop control.
+
+Operators (operators.py): Defines Operator enums used within BinaryOperation and UnaryOperation nodes. Includes mappings from Python operators.
+
+VEX-Specific Nodes (vex_nodes.py): Subclasses of FunctionCall tailored to represent common VEX API patterns.
+
+VexAPICall: Base class for VEX calls.
+
+MotorControl: Calls related to motors (e.g., motor.spin).
+
+SensorReading: Calls related to sensors (e.g., sensor.value).
+
+TimingControl: Calls like wait.
+
+DisplayOutput: Calls related to screen output (e.g., brain.screen.print).
+
+Usage
+
+These node classes are typically instantiated by the parser (vex_ast.parser) during the code parsing process. Visitors (vex_ast.visitors) then interact with these node objects to perform tasks.

vex_ast/parser/README.md

@@ -0,0 +1,47 @@
+Code Parser (vex_ast.parser)
+
+This directory contains the components responsible for parsing VEX V5 Python source code and constructing the Abstract Syntax Tree (AST).
+
+Purpose
+
+The parser's role is to take raw source code (as a string or from a file) and transform it into the structured AST representation defined in vex_ast.ast. It handles syntax rules, identifies different code constructs, and builds the corresponding tree of nodes.
+
+Key Components
+
+Interfaces (interfaces.py):
+
+IParser: Protocol defining the essential parse() method that all parser implementations must provide.
+
+BaseParser: An abstract base class providing common functionality, such as integrating with the ErrorHandler.
+
+Node Factory (factory.py):
+
+NodeFactory: Implements the Factory pattern. It provides methods (create_identifier, create_binary_operation, etc.) to instantiate specific AST node types defined in vex_ast.ast. This decouples the main parsing logic from the details of node creation and allows for easier management of node instantiation, including attaching source locations and potentially handling errors during creation.
+
+Python Parser (python_parser.py):
+
+PythonParser: The concrete implementation of IParser. It leverages Python's built-in ast module to parse the input Python code into a standard Python AST.
+
+It then traverses the Python AST, using the NodeFactory to convert the standard Python nodes (ast.Assign, ast.Call, ast.BinOp, etc.) into the corresponding custom VEX AST nodes (Assignment, FunctionCall, BinaryOperation, etc.).
+
+Provides convenience functions parse_string and parse_file.
+
+Workflow
+
+The user calls parse_string or parse_file.
+
+An instance of PythonParser is created with the source code and an optional ErrorHandler.
+
+The PythonParser uses Python's ast.parse to generate a standard Python AST.
+
+The PythonParser walks through the Python AST. For each Python ast node, it determines the corresponding VEX AST node type.
+
+It calls the appropriate create_... method on its internal NodeFactory instance, passing the necessary components (sub-expressions, statements, names, values) converted recursively.
+
+The NodeFactory creates the VEX AST node, potentially adding source location information extracted from the original Python ast node.
+
+This process continues recursively until the entire Python AST is converted into the custom VEX AST (Program node).
+
+Any syntax errors during Python parsing or unsupported constructs during conversion are reported via the ErrorHandler.
+
+The final Program node representing the VEX AST is returned.

vex_ast/registry/README.md

@@ -0,0 +1,29 @@
+# VEX AST Registry Package (vex_ast.registry)
+
+This package manages the registration and organization of VEX V5 Robot Python language features, including functions, objects, and other elements.
+
+Purpose
+
+The registry provides a centralized system for defining and accessing information about VEX-specific language constructs. This information is used by the parser, type checker, and other tools to understand and process VEX code.
+
+Structure
+
+The package is organized into several modules:
+
+*   `categories.py`: Defines categories for organizing registry entries.
+*   `language_map.py`: Maps VEX language features to their Python equivalents.
+*   `registry.py`: Implements the core registry logic.
+*   `signature.py`: Defines the structure for function signatures.
+*   `simulation_behavior.py`: Specifies how VEX features should behave in a simulation environment.
+*   `validation.py`: Provides validation rules for registry entries.
+*   `functions/`: Contains submodules for specific function categories (e.g., drivetrain, motor, sensors).
+
+Key Concepts
+
+*   Registration: VEX language features are registered with the registry, providing metadata about their syntax, semantics, and simulation behavior.
+*   Organization: The registry organizes features into categories and subcategories for easy access and management.
+*   Validation: Registry entries are validated to ensure consistency and correctness.
+
+Usage
+
+The registry is used internally by the VEX AST parser and other tools. It is not typically accessed directly by users.

vex_ast/types/README.md

@@ -0,0 +1,26 @@
+# VEX AST Types Package (vex_ast.types)
+
+This package defines the type system used for the VEX V5 Robot Python language.
+
+Purpose
+
+The type system provides a way to represent and reason about the types of values in VEX code. This information is used for type checking, code optimization, and other purposes.
+
+Structure
+
+The package is organized into several modules:
+
+*   `base.py`: Defines base classes for types.
+*   `enums.py`: Defines enums for different type categories.
+*   `objects.py`: Defines classes for representing objects.
+*   `primitives.py`: Defines classes for representing primitive types (e.g., int, float, string, boolean).
+*   `type_checker.py`: Implements the type checking logic.
+
+Key Concepts
+
+*   Types: Represent the kind of value that a variable or expression can have.
+*   Type checking: The process of verifying that the types in a program are consistent.
+
+Usage
+
+The type system is used internally by the VEX AST parser, type checker, and other tools. It is not typically accessed directly by users.

vex_ast/utils/README.md

@@ -0,0 +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.

vex_ast/visitors/README.md

@@ -0,0 +1,49 @@
+AST Visitors (vex_ast.visitors)
+
+This directory provides implementations of the Visitor design pattern for traversing and operating on the VEX Abstract Syntax Tree (AST).
+
+Purpose
+
+Visitors allow you to perform operations on the AST without modifying the AST node classes themselves. They provide a clean and extensible way to implement various forms of analysis, transformation, or code generation based on the AST structure.
+
+Core Concepts
+
+Visitor Pattern: The core idea is double dispatch. You call visitor.visit(node), which in turn calls node.accept(visitor). The node's accept method then calls the specific visit_NodeType(node) method on the visitor corresponding to its own type.
+
+Base Visitor (base.py):
+
+AstVisitor[T_VisitorResult]: An abstract generic base class for all visitors. It defines the main visit entry point and provides default visit_NodeType methods that typically delegate to a generic_visit method. Subclasses must implement generic_visit and can override specific visit_NodeType methods for custom behavior.
+
+Traversal: The generic_visit method in concrete visitors often iterates through the node's children (obtained via node.get_children()) and calls self.visit(child) recursively to traverse the tree.
+
+Provided Visitors
+
+Printer (printer.py):
+
+PrintVisitor: Traverses the AST and generates a formatted, indented string representation of the tree structure, including node types, attributes, and source locations (if available). Useful for debugging and understanding the AST structure.
+
+Analyzers (analyzer.py):
+
+NodeCounter: Traverses the AST and counts the total number of nodes, optionally keeping track of counts per node type.
+
+VariableCollector: Traverses the AST and collects the names of all variables referenced (VariableReference nodes).
+
+Usage
+
+Instantiate a Visitor: Create an instance of the desired visitor class (e.g., printer = PrintVisitor()).
+
+Parse Code: Obtain the root node (Program object) of the AST using vex_ast.parse_string or vex_ast.parse_file.
+
+Start Visitation: Call the visitor's visit method with the root node (e.g., result = printer.visit(ast_root)).
+
+Process Result: The visit method will return a result whose type depends on the specific visitor (T_VisitorResult). For PrintVisitor, it's a string; for NodeCounter, an integer; for VariableCollector, a set of strings.
+
+Extensibility
+
+You can create custom visitors to perform specific tasks (e.g., type checking, code optimization, simulation execution) by:
+
+Creating a new class that inherits from AstVisitor[YourResultType].
+
+Implementing the generic_visit method to define default behavior and traversal logic.
+
+Overriding specific visit_NodeType methods for nodes where specialized logic is required.

{vex_ast-0.1.0.dist-info → vex_ast-0.2.0.dist-info}/METADATA

@@ -1,13 +1,14 @@
 Metadata-Version: 2.4
 Name: vex_ast
-Version: 0.1.0
+Version: 0.2.0
 Summary: A Python package for generating Abstract Syntax Trees for VEX V5 code.
-Home-page: https://github.com/teowy/vex_ast
+Home-page: https://github.com/heartx2/vex_ast
 Author: Chaze
-Author-email: chazelexander@example.com
+Author-email: Chaze <chazelexander@gmail.com>
+License: HX2's Vex AST © 2025 by charkwayteowy is licensed under CC BY-NC 4.0
+Project-URL: Repository, https://github.com/heartx2/vex_ast
 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
@@ -17,14 +18,11 @@ Classifier: Topic :: Software Development :: Compilers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-python
-Dynamic: summary
 
 # VEX AST Generator
 
@@ -60,7 +58,7 @@ The core library is within the `vex_ast` directory:
 
 1.  **Clone the repository:**
     ```bash
-    git clone https://github.com/yourusername/vex_ast.git # Replace with actual URL
+    git clone https://github.com/heartx2/vex_ast # Replace with actual URL
     cd vex_ast
     ```
 
@@ -173,4 +171,4 @@ Contributions are welcome! Please follow the established coding standards and en
 
 ## License
 
-This project is licensed under the MIT License - see the LICENSE file for details (You'll need to add a LICENSE file).
+HX2's Vex AST © 2025 by charkwayteowy is licensed under CC BY-NC 4.0

{vex_ast-0.1.0.dist-info → vex_ast-0.2.0.dist-info}/RECORD

@@ -1,4 +1,7 @@
+vex_ast/README.md,sha256=tRaq6n2Ab4IahHSo3utW2imVuTrJu_7zaelgF-lGBYo,2007
+vex_ast/READMEAPI.md,sha256=hGn4IMT9NnI_LW0kd36BdKKXdIhYFLbQcgbVj1EWJps,9107
 vex_ast/__init__.py,sha256=YPsS_1ab9-G3WYmyxQobDA1U8y5KJkj2qxm_p_s9Oow,1724
+vex_ast/ast/README.md,sha256=7IQDHEXmKyJ8zfJNwa3pMGTDZKVPMFD0YeHT06ATRyM,3205
 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
@@ -9,11 +12,13 @@ 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/README.md,sha256=P1qq_97skpgluLDpNu9V_pAdkuF9StjkzOEXJJYpEuM,2565
 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/README.md,sha256=J8xEXEscEZhWa6wmn05kjE395AjrV7p2h7nq4SXI5uE,1535
 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
@@ -26,16 +31,20 @@ vex_ast/serialization/__init__.py,sha256=qPTEiMjU8hpVxNH5z4MY7Yj60AxuFurjXZStjhW
 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/types/README.md,sha256=Wd3jBShiNXNc3iJ69Qps5_0mBq8QVEd_Gz5OachfS34,1029
+vex_ast/utils/README.md,sha256=Y9RJMQTqQbpjVkvYJmpeRihD1zfW9PhNL_LgoDJ84ak,1945
 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/README.md,sha256=BKDj8LMuBlCrzgSSLmCkbET7WIqgxe-oCkqQbqXekrE,2725
 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.2.0.dist-info/licenses/LICENSE,sha256=IOSlfCuxGv4OAg421BRDKVi16RZ7-5kCMJ4B16r4kuc,69
+vex_ast-0.2.0.dist-info/METADATA,sha256=xGeh73jQORTXs2-uS-qgiH3aW-Pdsk31J1WW-tKQREE,5295
+vex_ast-0.2.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+vex_ast-0.2.0.dist-info/top_level.txt,sha256=MoZGrpKgNUDiqL9gWp4q3wMw3q93XPEEjmBNPJQcNAs,8
+vex_ast-0.2.0.dist-info/RECORD,,

vex_ast-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+HX2's Vex AST © 2025 by charkwayteowy is licensed under CC BY-NC 4.0