ast-pattern-engine 1.0.1__tar.gz → 1.0.2__tar.gz

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/.github/workflows/ci.yml

@@ -1,69 +1,86 @@
-name: CI
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  format:
-    runs-on: ubuntu-latest
-    if: github.event_name == 'push'
-    permissions:
-      contents: write
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-      with:
-        enable-cache: true
-
-    - name: Auto-format with Ruff
-      run: uv run ruff format
-
-    - name: Auto-fix lint with Ruff
-      run: uv run ruff check --fix
-
-    - name: Commit formatting changes
-      uses: stefanzweifel/git-auto-commit-action@v5
-      with:
-        commit_message: "style: auto-format with ruff"
-
-  test:
-    runs-on: ubuntu-latest
-    needs: format
-    if: always()
-    strategy:
-      matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        ref: ${{ github.ref }}
-
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-      with:
-        enable-cache: true
-
-    - name: Install dependencies
-      run: uv sync --all-extras --all-groups
-
-    - name: Lint with Ruff
-      run: uv run ruff check
-
-    - name: Run tests with pytest
-      run: uv run pytest --cov=src --cov-report=xml
-
-    - name: Upload coverage reports to Codecov
-      uses: codecov/codecov-action@v4
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+name: CI
+
+on:
+  push:
+    branches: [ "main", "dev" ]
+  pull_request:
+    branches: [ "main", "dev" ]
+
+jobs:
+  format-and-lint:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+    permissions:
+      contents: write
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+
+    - name: Auto-format with Ruff
+      run: uv run ruff format
+
+    - name: Lint with Ruff
+      run: uv run ruff check --exit-zero
+
+    - name: Commit formatting changes
+      uses: stefanzweifel/git-auto-commit-action@v5
+      with:
+        commit_message: "style: auto-format with ruff"
+
+  test:
+    runs-on: ubuntu-latest
+    needs: format-and-lint
+    if: always()
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        ref: ${{ github.ref }}
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+
+    - name: Install dependencies
+      run: uv sync --all-extras --all-groups
+
+    - name: Run tests with pytest
+      run: uv run pytest --cov=src --cov-report=xml
+
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v5
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  deploy-docs:
+    runs-on: ubuntu-latest
+    needs: test
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    permissions:
+      contents: write
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+
+    - name: Install Docs Dependencies
+      run: uv sync --only-group docs
+
+    - name: Deploy Docs
+      run: uv run mkdocs gh-deploy --force

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ast-pattern-engine
-Version: 1.0.1
+Version: 1.0.2
 Summary: A library for regex-inspired fine-grained AST pattern matching and replacing
 Project-URL: Homepage, https://github.com/80sVectorz/ast_pattern_engine
 Project-URL: Repository, https://github.com/80sVectorz/ast_pattern_engine
@@ -21,6 +21,13 @@ Provides-Extra: dev
 Requires-Dist: pytest; extra == 'dev'
 Description-Content-Type: text/markdown
 
+![PyPI - Version](https://img.shields.io/pypi/v/ast-pattern-engine)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ast-pattern-engine)
+![Pytest](https://img.shields.io/badge/pytest-tested-orange)
+![MIT License](https://img.shields.io/badge/License-MIT-blue)
+![Codecov](https://codecov.io/gh/80sVectorz/ast_pattern_engine/branch/main/graph/badge.svg)
+![GitHub Workflow Status](https://github.com/80sVectorz/ast_pattern_engine/actions/workflows/ci.yml/badge.svg)
+
 # AST Pattern Engine
 
 A powerful, programmatic, regex-inspired AST pattern matching and manipulation library for Python.

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/README.md

@@ -1,3 +1,10 @@
+![PyPI - Version](https://img.shields.io/pypi/v/ast-pattern-engine)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ast-pattern-engine)
+![Pytest](https://img.shields.io/badge/pytest-tested-orange)
+![MIT License](https://img.shields.io/badge/License-MIT-blue)
+![Codecov](https://codecov.io/gh/80sVectorz/ast_pattern_engine/branch/main/graph/badge.svg)
+![GitHub Workflow Status](https://github.com/80sVectorz/ast_pattern_engine/actions/workflows/ci.yml/badge.svg)
+
 # AST Pattern Engine
 
 A powerful, programmatic, regex-inspired AST pattern matching and manipulation library for Python.

ast_pattern_engine-1.0.2/docs/guide.md

@@ -0,0 +1,57 @@
+# Guide & Philosophy
+
+## Philosophy & Design
+
+Instead of having to rely on fragile direct source-code manipulation or slightly better magic string-expression-based AST manipulation engines, `ast_pattern_engine` provides an internal DSL for building explicit, structural patterns.
+
+It explicitly avoids string-based expressions because they simply don't scale well. For robust code-analysis you must have a grasp of the underlying AST structure.
+
+The package started as a component for another project and was later spun off into it's own clean package.
+Early experiences made it clear that large expressions aren't the way to go for AST manipulation.
+A staged approach is much more robust and easier to reason about.
+
+The package is intentionally kept somewhat limited to encourage using custom logic for more advanced filtering and analysis. Rather than building extremely nested gigantic expressions, it's encouraged to build small, focused patterns and visitors.
+Like casting a wide net and progressively filtering down in stages.
+
+## Primitives
+
+The library provides several primitives to build robust sequences:
+
+- `NodePattern`: Match specific AST node types and assert on their fields.
+- `Collect` / `Bind`: Extract sub-trees out of a matched pattern to use in your handlers. `Bind` assigns a name to a matched node so that it can be processed during transformation.
+- `OneOf`: Match one of several possible patterns (similar to regex `|`).
+- `Repetition`: Match a pattern sequentially 1 or more times (similar to regex `*` and `+`).
+- `Optional`: Match a pattern 0 or 1 times (similar to regex `?`).
+- `Filter`: Apply arbitrary Python lambdas to check node states during matching.
+
+## Building Patterns
+
+A typical pattern is a sequence of `Pattern` objects. For instance, finding a sequence of assignments:
+
+```python
+from ast_pattern_engine import NodePattern, Bind
+import ast
+
+# Matches an assignment of any value to "x"
+assign_to_x = NodePattern(
+    ast.Assign,
+    targets=[NodePattern(ast.Name, id="x")],
+    value=Bind("x_value")
+)
+```
+
+## Transformers and Finders
+
+Once a pattern is matched, you often want to act on it.
+
+- **Transformers** (`PatternTransformer`, `BottomUpPatternTransformer`): These visitors replace matched subtrees with new nodes generated by your handlers. A handler receives the bound variables (E.G `Bind("x")`, `Collect()) and returns the replacement nodes.
+- **Finders** (`PatternFinder`, `SingleOccurrenceFinder`): These visitors just locate where patterns occur in the tree without modifying it. Useful for analysis or linting.
+
+## Templates
+
+To reduce boilerplate when building patterns, the library includes a `templates` module with helpers for common operations:
+- `match_call(func_name, **kwargs)`
+- `match_assign(target_name, value)`
+- `match_in_expr(pattern)`
+
+Using templates allows you to write dense, readable matching rules quickly.

ast_pattern_engine-1.0.2/docs/index.md

@@ -0,0 +1,46 @@
+# AST Pattern Engine
+
+A powerful, programmatic, regex-inspired AST pattern matching and manipulation library for Python.
+
+## Quick Start
+
+Here is a simple pipeline that rewrites `dict.get("key")` calls into direct subscript access `dict["key"]`:
+
+```python
+from typing import Any
+import ast
+from ast_pattern_engine import BottomUpPatternTransformer, Bind, NodePattern
+
+source = "value = my_dict.get(other_dict.get('foo'))"
+tree = ast.parse(source)
+
+# 1. Build the explicit structural pattern
+# Matches: <obj>.get(<key>)
+pattern = [
+    NodePattern(
+        ast.Call,
+        func=NodePattern(ast.Attribute, attr="get", value=Bind("obj")),
+        args=Bind("key"),
+    )
+]
+
+# 2. Define the rewrite logic
+def rewrite_dict_get(bindings: dict[str, Any]) -> list[ast.AST]:
+    obj = bindings["obj"]
+    key = bindings["key"][0]  # args is a list
+
+    # Return the new node to replace the matched node
+    new_node = ast.Subscript(value=obj, slice=key, ctx=ast.Load())
+    return [new_node]
+
+# 3. Apply the transformer
+# We use BottomUpPatternTransformer so nested `.get()` calls
+# are safely transformed from the inside-out.
+transformer = BottomUpPatternTransformer(pattern, {"key": rewrite_dict_get})
+transformer.visit(tree)
+
+print(ast.unparse(tree))
+# Output: value = my_dict[other_dict['foo']]
+```
+
+For more in-depth examples, refer to the [Guide](guide.md) or the [API Reference](reference/core.md).

ast_pattern_engine-1.0.2/docs/reference/core.md

@@ -0,0 +1,11 @@
+# Core & Engine
+
+This page documents the core base classes and the engine used to match sequences.
+
+::: ast_pattern_engine.core
+    options:
+      show_root_heading: true
+
+::: ast_pattern_engine.engine
+    options:
+      show_root_heading: true

ast_pattern_engine-1.0.2/docs/reference/nodes.md

@@ -0,0 +1,19 @@
+# Pattern Nodes
+
+Pattern nodes are the basic building blocks to construct matching logic over an AST.
+
+## Basic Nodes
+
+Basic nodes allow matching structural properties, capturing values, and simple boolean combinations.
+
+::: ast_pattern_engine.nodes.basic
+    options:
+      show_root_heading: true
+
+## Sequence Nodes
+
+Sequence nodes allow matching groups of adjacent nodes, similar to regex patterns.
+
+::: ast_pattern_engine.nodes.sequences
+    options:
+      show_root_heading: true

ast_pattern_engine-1.0.2/docs/reference/templates.md

@@ -0,0 +1,7 @@
+## Templates
+
+Templates provide convenient helper functions for generating common patterns.
+
+::: ast_pattern_engine.templates
+    options:
+      show_root_heading: true

ast_pattern_engine-1.0.2/docs/reference/visitors.md

@@ -0,0 +1,9 @@
+# AST Visitors
+
+Visitors use the pattern matching engine to find or transform abstract syntax trees.
+
+## Finders and Transformers
+
+::: ast_pattern_engine.visitors
+    options:
+      show_root_heading: true

ast_pattern_engine-1.0.2/docs/stylesheets/extra.css

@@ -0,0 +1,26 @@
+/* Add a simple visual divider above each mkdocstrings API object */
+.doc-object {
+    border-top: 1px solid var(--md-default-fg-color--lightest);
+    margin-top: 3rem;
+    padding-top: 1rem;
+}
+
+/* Remove the divider from the very first item on the page */
+.doc-object:first-child {
+    border-top: none;
+    margin-top: 0;
+    padding-top: 0;
+}
+
+/* Ensure the heading sits neatly below the divider */
+.doc-heading,
+.doc-symbol-heading {
+    margin-top: 0 !important;
+}
+
+/* Indent the contents (docstrings, parameters, methods) of classes and functions */
+.doc-contents {
+    margin-left: 1.5rem;
+    padding-left: 1rem;
+    border-left: 2px solid var(--md-default-fg-color--lightest);
+}

ast_pattern_engine-1.0.2/mkdocs.yaml

@@ -0,0 +1,50 @@
+site_name: AST Pattern Engine
+site_url: https://80svectorz.github.io/ast_pattern_engine/
+repo_url: https://github.com/80sVectorz/ast_pattern_engine
+
+theme:
+  name: material
+  palette:
+    - scheme: slate
+      primary: teal
+      accent: teal
+  features:
+    - navigation.tabs
+    - content.code.copy
+    - toc.follow
+
+plugins:
+  - search
+  - mkdocstrings:
+      default_handler: python
+      handlers:
+        python:
+          options:
+            docstring_style: google
+            show_root_heading: true
+            show_source: true
+            separate_signature: true
+            show_signature_annotations: true
+            show_symbol_type_heading: true
+            show_symbol_type_toc: true
+
+markdown_extensions:
+  - pymdownx.highlight:
+      anchor_linenums: true
+      line_spans: __span
+      pygments_style: material
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+  - pymdownx.superfences
+
+extra_css:
+  - stylesheets/extra.css
+
+nav:
+  - Home: index.md
+  - Guide & Philosophy: guide.md
+  - API Reference:
+      - Core & Engine: reference/core.md
+      - Pattern Nodes: reference/nodes.md
+      - AST Visitors: reference/visitors.md
+      - QoL Templates: reference/templates.md

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ast-pattern-engine"
-version = "1.0.1"
+version = "1.0.2"
 description = "A library for regex-inspired fine-grained AST pattern matching and replacing"
 readme = "README.md"
 authors = [
@@ -42,6 +42,8 @@ dev = [
     "pytest-cov>=7.1.0",
     "ruff>=0.11.0",
 ]
-
-[tool.ruff.lint]
-ignore = ["F841"] # Ignore unused variable assignments
+docs = [
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.7.6",
+    "mkdocstrings[python]>=1.0.4",
+]

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/src/ast_pattern_engine/nodes/basic.py

@@ -11,10 +11,10 @@ from ast_pattern_engine.visitors import SingleOccurrenceFinder
 
 
 class Bind(Pattern):
-    """Bind the current node to `name`.
+    """Bind the current node to `key`.
 
     This is syntactic sugar for:
-        >>> Collect(WildCard(), "x")
+    >>> Collect(WildCard(), "x")
 
     Args:
         key: The key to bind the node(s) or value(s) to.
@@ -23,6 +23,11 @@ class Bind(Pattern):
     key: str
 
     def __init__(self, key: str):
+        """Bind node.
+
+        Args:
+            key: The key to bind the node(s) or value(s) to.
+        """
         self.key = key
 
     def match_node(
@@ -66,7 +71,16 @@ class NodePattern(Pattern):
         **field_patterns: Patterns or exact values to match against the node's fields.
     """
 
+    node_type: type[ast.AST]
+    field_patterns: dict[str, Pattern | Any]
+
     def __init__(self, node_type: type[ast.AST], **field_patterns: Pattern | Any):
+        """NodePattern node.
+
+        Args:
+            node_type: The AST node class to match (e.g., ast.Assign).
+            **field_patterns: Patterns or exact values to match against the node's fields.
+        """
         self.node_type = node_type
         self.field_patterns = field_patterns
 
@@ -119,12 +133,15 @@ class Collect(Pattern):
     """
 
     pattern: Pattern
-    """The pattern to match."""
-
     key: str
-    """The key to bind the pattern result to."""
 
     def __init__(self, pattern: Pattern, key: str):
+        """Collect node.
+
+        Args:
+            pattern: The pattern to match.
+            key: The key to bind the pattern result to.
+        """
         self.pattern = pattern
         self.key = key
 
@@ -178,12 +195,15 @@ class Filter(Pattern):
     """
 
     predicate: Callable[[Any], bool]
-    """The predicate to match."""
-
     key: str | None
-    """The key to bind the node to."""
 
     def __init__(self, predicate: Callable[[Any], bool], key: str | None = None):
+        """Filter node.
+
+        Args:
+            predicate: A callable that returns True if the node matches.
+            key: Optional key to bind the matched node to.
+        """
         self.predicate = predicate
         self.key = key
 
@@ -215,7 +235,14 @@ class Not(Pattern):
         pattern: The pattern that must fail for this to match.
     """
 
+    pattern: Pattern
+
     def __init__(self, pattern: Pattern):
+        """Not node.
+
+        Args:
+            pattern: The pattern that must fail for this to match.
+        """
         self.pattern = pattern
 
     def match_node(
@@ -243,7 +270,14 @@ class Contains(Pattern):
         pattern: The pattern or sequence of patterns to search for in the sub-tree.
     """
 
+    pattern: Sequence[Pattern]
+
     def __init__(self, pattern: Sequence[Pattern]):
+        """Contains node.
+
+        Args:
+            pattern: The pattern or sequence of patterns to search for in the sub-tree.
+        """
         self.pattern = list(pattern)
 
     def match_node(
@@ -278,9 +312,13 @@ class AllOf(Pattern):
     """
 
     patterns: Sequence[Pattern]
-    """The patterns to match."""
 
     def __init__(self, patterns: Sequence[Pattern]):
+        """AllOf node.
+
+        Args:
+            patterns: Sequence of patterns that must all match the node.
+        """
         self.patterns = list(patterns)
 
     def match_node(
@@ -310,9 +348,13 @@ class AnyOf(Pattern):
     """
 
     patterns: list[Pattern]
-    """The patterns to match."""
 
     def __init__(self, patterns: Sequence[Pattern]):
+        """AnyOf node.
+
+        Args:
+            patterns: Sequence of patterns where at least one must match.
+        """
         self.patterns = list(patterns)
 
     def match_node(

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/src/ast_pattern_engine/nodes/sequences.py

@@ -22,16 +22,16 @@ class Repetition(SequencePattern):
     """Matches a single pattern zero or more times.
 
     Also supports specifying min and max match count thresholds
+
+    Args:
+        pattern: The pattern to match.
+        min_matches: Minimum number of matches required. Default is 1.
+        max_matches: Maximum number of allowed matches. Defaults to None.
     """
 
     pattern: Pattern
-    """The pattern to match."""
-
     min_matches: int
-    """Minimum number of matches required. Defaults to 1."""
-
     max_matches: int | None
-    """Maximum number of allowed matches. Defaults to None."""
 
     def __init__(
         self,
@@ -42,9 +42,9 @@ class Repetition(SequencePattern):
         """Repetition node.
 
         Args:
-            pattern: The AST pattern.
-            min_matches: Min number of matches required. Default is 1.
-            max_matches: Max number of allowed matches. Defaults to None.
+            pattern: The pattern to match.
+            min_matches: Minimum number of matches required. Default is 1.
+            max_matches: Maximum number of allowed matches. Defaults to None.
         """
         self.pattern = pattern
         self.min_matches = min_matches
@@ -52,13 +52,15 @@ class Repetition(SequencePattern):
 
 
 class PatternGroup(SequencePattern):
-    """Matches a compound pattern/pattern group to an AST node sequence."""
+    """Matches a compound pattern/pattern group to an AST node sequence.
 
-    pattern: Sequence[Pattern]
-    """The compound pattern to match."""
+    Args:
+        pattern: The compound pattern to match.
+        key: Optional key to bind the matched pattern to.
+    """
 
+    pattern: Sequence[Pattern]
     key: str | None
-    """Optional key to bind the matched pattern to."""
 
     def __init__(self, pattern: Sequence[Pattern], key: str | None = None) -> None:
         """PatternGroup node.
@@ -84,30 +86,34 @@ class OneOf(SequencePattern):
     """
 
     patterns: list[Pattern]
-    """The patterns to match."""
-
     strict: bool
-    """Whether to be strict and only match if *exactly* one pattern matches."""
-
     key: str | None
-    """Optional key to bind the matched pattern to."""
 
     def __init__(
         self, patterns: Sequence[Pattern], strict: bool = False, key: str | None = None
     ) -> None:
+        """OneOf node.
+
+        Args:
+            patterns: The patterns to match
+            strict: Whether to be strict and only match if *exactly* one pattern matches
+            key: Optional key to bind the matched pattern to
+        """
         self.patterns = list(patterns)
         self.strict = strict
         self.key = key
 
 
 class Optional(SequencePattern):
-    """Matches a pattern zero or one times."""
+    """Matches a pattern zero or one times.
 
-    pattern: Pattern
-    """The pattern to match."""
+    Args:
+        pattern: The pattern to match.
+        key: Optional key to bind the matched pattern to.
+    """
 
+    pattern: Pattern
     key: str | None
-    """Optional key to bind the matched pattern to."""
 
     def __init__(self, pattern: Pattern, key: str | None = None) -> None:
         """Optional node.

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/src/ast_pattern_engine/visitors.py

@@ -29,6 +29,9 @@ class PatternTransformer(ast.NodeTransformer):
     Args:
         pattern: Sequence of pattern nodes matched against each candidate span.
         actions: Mapping from collect keys to replacement handlers or None.
+
+    Attributes:
+        matches: List of bindings for each match.
     """
 
     def __init__(
@@ -359,6 +362,9 @@ class BottomUpPatternTransformer(ast.NodeTransformer):
     Args:
         pattern: Sequence of pattern nodes matched against each candidate span.
         actions: Mapping from collect keys to replacement handlers or None.
+
+    Attributes:
+        matches: List of bindings for each match.
     """
 
     def __init__(
@@ -442,6 +448,10 @@ class PatternFinder(ast.NodeVisitor):
 
     Args:
         pattern: Sequence of pattern nodes to search for.
+
+    Attributes:
+        matches: List of bindings for each match.
+        visited: Set of visited node IDs.
     """
 
     def __init__(self, pattern: Sequence[Pattern]):
@@ -487,6 +497,10 @@ class SingleOccurrenceFinder(ast.NodeVisitor):
 
     Args:
         pattern: Sequence of pattern nodes to search for.
+
+    Attributes:
+        match_node: The first match node, if any.
+        match_bindings: The bindings for the first match, if any.
     """
 
     match_node: ast.AST | None
@@ -497,15 +511,15 @@ class SingleOccurrenceFinder(ast.NodeVisitor):
         self.match_node = None
         self.match_bindings = {}
         self.pattern = pattern
-        self.found = False
+        self._found_match = False
 
     def visit(self, node: ast.AST):
-        if self.found:
+        if self._found_match:
             return  # short-circuit: we've already found a match
 
         res = _match_patterns(self.pattern, [node], 0, {})
         if res:
-            self.found = True
+            self._found_match = True
             self.match_node = node
             self.match_bindings = res[0][0]
             return
@@ -516,12 +530,12 @@ class SingleOccurrenceFinder(ast.NodeVisitor):
                 for item in val:
                     if isinstance(item, ast.AST):
                         self.visit(item)
-                        if self.found:
+                        if self._found_match:
                             return
             elif isinstance(val, ast.AST):
                 self.visit(val)
-                if self.found:
+                if self._found_match:
                     return
 
     def found_match(self) -> bool:
-        return self.found
+        return self._found_match

{ast_pattern_engine-1.0.1 → ast_pattern_engine-1.0.2}/tests/visitors/test_single_occurrence_finder.py

@@ -31,6 +31,6 @@ def test_single_occurrence_finder_early_exit():
     finder = SingleOccurrenceFinder(pattern)
 
     # We manually set found to True to test early exit in visit
-    finder.found = True
+    finder._found_match = True
     finder.visit(tree)
     assert finder.match_node is None  # Didn't actually match because it early exited

ast_pattern_engine-1.0.1/src/ast_pattern_engine/plumbing.py

@@ -1,2 +0,0 @@
-# This module previously contained the Message/AnnounceBinding plumbing.
-# That system has been replaced by stateless _force_list context passing.