syncraft 0.2.0__tar.gz → 0.2.1__tar.gz

{syncraft-0.2.0 → syncraft-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.2.0
+Version: 0.2.1
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT

{syncraft-0.2.0 → syncraft-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "syncraft"
-version = "0.2.0"
+version = "0.2.1"
 description = "Parser combinator library"
 license = "MIT"
 license-files = ["LICENSE"]

{syncraft-0.2.0 → syncraft-0.2.1}/syncraft/algebra.py

@@ -7,7 +7,6 @@ from typing import (
 import traceback
 from dataclasses import dataclass, replace
 from weakref import WeakKeyDictionary
-from abc import ABC
 from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind, shallow_dict
 from syncraft.constraint import Bindable
 
@@ -75,12 +74,16 @@ class Error:
 
 
 @dataclass(frozen=True)        
-class Algebra(ABC, Generic[A, S]):
+class Algebra(Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################
     run_f: Callable[[S, bool], Either[Any, Tuple[A, S]]] 
     name: Hashable
     _cache: ClassVar[WeakKeyDictionary[Any, Dict[Any, object | Either[Any, Tuple[Any, Any]]]]] = WeakKeyDictionary()
 
+    @classmethod
+    def state(cls, *args:Any, **kwargs:Any)->Optional[S]: 
+        return None
+        
     def named(self, name: Hashable) -> 'Algebra[A, S]':
         return replace(self, name=name)
 

{syncraft-0.2.0 → syncraft-0.2.1}/syncraft/generator.py

@@ -16,14 +16,14 @@ from syncraft.ast import (
     Choice, Many, ChoiceKind,
     Then, ThenKind, Marked
 )
-
+from syncraft.constraint import FrozenDict
 from syncraft.syntax import Syntax
 from sqlglot import TokenType
 import re
 import rstr
 from functools import lru_cache
 import random
-from rich import print
+
 from syncraft.constraint import Bindable
 
 T = TypeVar('T', bound=TokenProtocol)  
@@ -144,6 +144,10 @@ class TokenGen(TokenSpec):
 
 @dataclass(frozen=True)
 class Generator(Algebra[ParseResult[T], GenState[T]]):  
+    @classmethod
+    def state(cls, ast: Optional[ParseResult[T]] = None, seed: int = 0, restore_pruned: bool = False)->GenState[T]:
+        return GenState.from_ast(ast=ast, seed=seed, restore_pruned=restore_pruned)
+
     def flat_map(self, f: Callable[[ParseResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
         def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
             try:
@@ -293,14 +297,9 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
 def generate(syntax: Syntax[Any, Any], 
             data: Optional[ParseResult[Any]] = None, 
             seed: int = 0, 
-            restore_pruned: bool = False) -> AST | Any:
-    gen = syntax(Generator)
-    state = GenState.from_ast(ast=data, seed=seed, restore_pruned=restore_pruned)
-    result = gen.run(state, use_cache=False)
-    if isinstance(result, Right):
-        return result.value[0]
-    assert isinstance(result, Left), "Generator must return Either[Any, Tuple[Any, Any]]"
-    return result.value
+            restore_pruned: bool = False) -> Tuple[AST, FrozenDict[str, AST]] | Tuple[Any, None]:
+    from syncraft.syntax import run
+    return run(syntax, Generator, False, ast=data, seed=seed, restore_pruned=restore_pruned)
 
 
     

{syncraft-0.2.0 → syncraft-0.2.1}/syncraft/parser.py

@@ -5,6 +5,7 @@ from typing import (
     Optional, List, Any, Tuple, TypeVar,
     Generic
 )
+from syncraft.constraint import FrozenDict
 from syncraft.algebra import (
     Either, Left, Right, Error, Algebra
 )
@@ -67,6 +68,11 @@ class ParserState(Bindable, Generic[T]):
     
 @dataclass(frozen=True)
 class Parser(Algebra[T, ParserState[T]]):
+    @classmethod
+    def state(cls, sql: str, dialect: str) -> ParserState[Token]:
+        tokens = tuple([Token(token_type=token.token_type, text=token.text) for token in tokenize(sql, dialect=dialect)])
+        return ParserState.from_tokens(tokens) 
+
     @classmethod
     def token(cls, 
               token_type: Optional[Enum] = None, 
@@ -182,21 +188,12 @@ def sqlglot(parser: Syntax[Any, Any],
     return parser.map(lambda tokens: [e for e in gp.parse(raw_tokens=tokens) if e is not None])
 
 
-def parse(syntax: Syntax[Any, Any], 
-          sql: str, 
-          dialect: str) -> AST | Any:
-    parser = syntax(Parser)
-    input: ParserState[Token] = token_state(sql, dialect=dialect)
-    result = parser.run(input, True)
-    if isinstance(result, Right):
-        return result.value[0]
-    assert isinstance(result, Left), "Parser must return Either[E, Tuple[A, S]]"
-    return result.value
+def parse(syntax: Syntax[Any, Any], sql: str, dialect: str) -> Tuple[AST, FrozenDict[str, AST]] | Tuple[Any, None]:
+    from syncraft.syntax import run
+    return run(syntax, Parser, True, sql=sql, dialect=dialect)
+
 
 
-def token_state(sql: str, dialect: str) -> ParserState[Token]:
-    tokens = tuple([Token(token_type=token.token_type, text=token.text) for token in tokenize(sql, dialect=dialect)])
-    return ParserState.from_tokens(tokens) 
 
 def token(token_type: Optional[Enum] = None, 
           text: Optional[str] = None, 

{syncraft-0.2.0 → syncraft-0.2.1}/syncraft/syntax.py

@@ -2,17 +2,17 @@ from __future__ import annotations
 
 from typing import (
     Optional, Any, TypeVar, Generic, Callable, Tuple, cast,
-    Type, Literal, List, overload
+    Type, Literal, List
 )
 from dataclasses import dataclass, field, replace
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Right
-from syncraft.constraint import Bindable
+from syncraft.algebra import Algebra, Error, Either, Right, Left
+from syncraft.constraint import Bindable, FrozenDict
 from syncraft.ast import Then, ThenKind, Marked, Choice, Many, ChoiceKind, Nothing, Collect, E, Collector
 from types import MethodType, FunctionType
 import keyword
 
-from rich import print
+
 
 def valid_name(name: str) -> bool:
     return (name.isidentifier() 
@@ -319,49 +319,15 @@ def success(value: Any) -> Syntax[Any, Any]:
 def choice(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
     return reduce(lambda a, b: a | b, parsers) if len(parsers) > 0 else success(Nothing())
 
-
-def all(*parsers: Syntax[Any, S]) -> Syntax[Then[Any, Any], S]:
-    return reduce(lambda a, b: a + b, parsers) if len(parsers) > 0 else success(Nothing())
-
-def first(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
-    return reduce(lambda a, b: a // b, parsers) if len(parsers) > 0 else success(Nothing())
-
-def last(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
-    return reduce(lambda a, b: a >> b, parsers) if len(parsers) > 0 else success(Nothing())
-
-def bind(* parsers: Syntax[Any, S] | Tuple[str, Syntax[Any, S]]) -> Syntax[Any, S]:
-    def is_named_parser(x: Any) -> bool:
-        return isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], str) and isinstance(x[1], Syntax)
-    
-    def to_parser(x: Syntax[Any, S] | Tuple[str, Syntax[Any, S]])->Syntax[Any, S]:
-        if isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], str) and isinstance(x[1], Syntax):
-            if isinstance(x[0], str):
-
-                return x[1].bind(x[0])
-            else:
-                raise ValueError(f"Invalid variable type(must be str | Variable): {x[0]}", x)
-        elif isinstance(x, Syntax):
-            return x
-        else:
-            raise ValueError(f"Invalid parser or tuple: {x}", x)
-    ret: Optional[Syntax[Any, S]] = None
-    has_data = False
-    for p in parsers:
-        just_parser = to_parser(p)
-        if has_data:
-            if ret is not None:
-                if is_named_parser(p):
-                    ret = ret + just_parser
-                else:
-                    ret = ret // just_parser
-            else:
-                ret = just_parser
-        else:
-            has_data = is_named_parser(p)
-            if ret is None:
-                ret = just_parser
-            else:
-                ret = ret >> just_parser
-    
-    return ret if ret is not None else success(Nothing()) 
+def run(syntax: Syntax[A, S], alg: Type[Algebra[A, S]], use_cache:bool, *args: Any, **kwargs: Any) -> Tuple[Any, FrozenDict[str, Any]] | Tuple[Any, None]:
+    parser = syntax(alg)
+    input: Optional[S] = alg.state(*args, **kwargs)
+    if input:
+        result = parser.run(input, use_cache=use_cache)
+        if isinstance(result, Right):
+            return result.value[0], result.value[1].binding.bound()
+        assert isinstance(result, Left), "Algebra must return Either[E, Tuple[A, S]]"
+        return result.value, None
+    else:
+        return Error(this=None, message="Algebra failed to create initial state"), None
 

{syncraft-0.2.0 → syncraft-0.2.1}/syncraft.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.2.0
+Version: 0.2.1
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT

{syncraft-0.2.0 → syncraft-0.2.1}/syncraft.egg-info/SOURCES.txt

@@ -21,5 +21,4 @@ tests/test_bimap.py
 tests/test_find.py
 tests/test_parse.py
 tests/test_to.py
-tests/test_until.py
-tests/test_var.py
+tests/test_until.py

{syncraft-0.2.0 → syncraft-0.2.1}/tests/test_bimap.py

@@ -12,31 +12,33 @@ def test1_simple_then() -> None:
     A, B, C = literal("a"), literal("b"), literal("c")
     syntax = A // B // C
     sql = "a b c"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
     value, bmap = generated.bimap()
     print(value)
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 def test2_named_results() -> None:
     A, B = literal("a").mark("x").mark('z'), literal("b").mark("y")
     syntax = A // B
     sql = "a b"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u,v = gen.generate(syntax, bmap(value))
+    assert u == generated
     
 
 
@@ -44,15 +46,16 @@ def test3_many_literals() -> None:
     A = literal("a")
     syntax = A.many()
     sql = "a a a"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 def test4_mixed_many_named() -> None:
@@ -60,30 +63,32 @@ def test4_mixed_many_named() -> None:
     B = literal("b")
     syntax = (A | B).many()
     sql = "a b a"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 def test5_nested_then_many() -> None:
     IF, THEN, END = literal("if"), literal("then"), literal("end")
     syntax = (IF.many() // THEN.many()).many() // END
     sql = "if if then end"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax, ast, restore_pruned=True)
+    generated, bound = gen.generate(syntax, ast, restore_pruned=True)
     print("---" * 40)
     print(generated)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value), restore_pruned=True) == generated
+    u, v = gen.generate(syntax, bmap(value), restore_pruned=True)
+    assert u == generated
 
 
 
@@ -91,12 +96,13 @@ def test_then_flatten():
     A, B, C = literal("a"), literal("b"), literal("c")
     syntax = A + (B + C)
     sql = "a b c"
-    ast = parse(syntax, sql, dialect='sqlite')
+    ast, bound = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 
@@ -106,24 +112,26 @@ def test_named_in_then():
     C = literal("c").mark("third")
     syntax = A + B + C
     sql = "a b c"
-    ast = parse(syntax, sql, dialect='sqlite')
+    ast, bound = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 def test_named_in_many():
     A = literal("x").mark("x")
     syntax = A.many()
     sql = "x x x"
-    ast = parse(syntax, sql, dialect='sqlite')
+    ast, bound = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 def test_named_in_or():
@@ -131,12 +139,13 @@ def test_named_in_or():
     B = literal("b").mark("b")
     syntax = A | B
     sql = "b"
-    ast = parse(syntax, sql, dialect='sqlite')
+    ast, bound = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 
@@ -148,21 +157,22 @@ def test_deep_mix():
     C = literal("c").mark("c")
     syntax = ((A + B) | C).many() + B
     sql = "a b a b c b"
-    ast = parse(syntax, sql, dialect='sqlite')
+    ast, bound = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax, ast)
+    generated, bound = gen.generate(syntax, ast)
     print('---' * 40)
     print(generated)
     assert ast == generated
     value, bmap = generated.bimap()
-    assert gen.generate(syntax, bmap(value)) == generated
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == generated
 
 
 def test_empty_many() -> None:
     A = literal("a")
     syntax = A.many()  # This should allow empty matches
     sql = ""
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, Error)
 
 
@@ -171,9 +181,10 @@ def test_backtracking_many() -> None:
     B = literal("b")
     syntax = (A.many() + B)  # must not eat the final "a" needed for B
     sql = "a a a a b"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     value, bmap = ast.bimap()
-    assert gen.generate(syntax, bmap(value)) == ast
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == ast
 
 def test_deep_nesting() -> None:
     A = literal("a")
@@ -181,7 +192,7 @@ def test_deep_nesting() -> None:
     for _ in range(100):
         syntax = syntax + A
     sql = " " .join("a" for _ in range(101))
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     assert ast is not None
 
 
@@ -189,7 +200,7 @@ def test_nested_many() -> None:
     A = literal("a")
     syntax = (A.many().many())  # groups of groups of "a"
     sql = "a a a"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, Many)
 
 
@@ -197,9 +208,10 @@ def test_named_many() -> None:
     A = literal("a").mark("alpha")
     syntax = A.many()
     sql = "a a"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     value, bmap = ast.bimap()
-    assert gen.generate(syntax, bmap(value)) == ast
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == ast
 
 
 def test_or_named() -> None:
@@ -207,9 +219,10 @@ def test_or_named() -> None:
     B = literal("b").mark("y")
     syntax = A | B
     sql = "b"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     value, bmap = ast.bimap()
-    assert gen.generate(syntax, bmap(value)) == ast
+    u, v = gen.generate(syntax, bmap(value))
+    assert u == ast
 
 
 def test_then_associativity() -> None:
@@ -218,7 +231,7 @@ def test_then_associativity() -> None:
     C = literal("c")
     syntax = A + B + C
     sql = "a b c"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     # Should be Then(Then(A,B),C)
     assert ast == Then(kind=ThenKind.BOTH, 
                                    left=Then(kind=ThenKind.BOTH, 
@@ -232,7 +245,7 @@ def test_ambiguous() -> None:
     B = literal("a") + literal("b")
     syntax = A | B
     sql = "a"
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     # Does it prefer A (shorter) or B (fails)? Depends on design.
     assert ast == Choice[Token, Token](value=TokenGen.from_string("a"), kind=ChoiceKind.LEFT)
 
@@ -245,19 +258,19 @@ def test_combo() -> None:
     sql = "a b a b c b"
     # Should fail, as we discussed earlier
     # the working syntax should be ((A + B) | C).many() + B
-    ast = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, Error)
-    ast = parse(((A + B) | C).many() + B, sql, dialect="sqlite")
+    ast, bound = parse(((A + B) | C).many() + B, sql, dialect="sqlite")
     assert not isinstance(ast, Error)
 
 
 def test_optional():
     A = literal("a").mark("a")
     syntax = A.optional()
-    ast1 = parse(syntax, "", dialect="sqlite")
+    ast1, bound = parse(syntax, "", dialect="sqlite")
     v1, _ = ast1.bimap()
     assert isinstance(v1, Nothing)
-    ast2 = parse(syntax, "a", dialect="sqlite")
+    ast2, bound = parse(syntax, "a", dialect="sqlite")
     v2, _ = ast2.bimap()
     assert v2 == Marked(name='a', value=TokenGen.from_string('a'))
 

{syncraft-0.2.0 → syncraft-0.2.1}/tests/test_find.py

@@ -43,5 +43,5 @@ def test_find()->None:
             + ifthenelse.mark('body')
             // ~END).to(While)
     sql = 'while b if a,b then c,d else a,d end if a,b then c,d else a,d end'
-    ast = parse(syntax, sql, dialect='sqlite')
+    ast, bound = parse(syntax, sql, dialect='sqlite')
     print(ast)

{syncraft-0.2.0 → syncraft-0.2.1}/tests/test_parse.py

@@ -13,21 +13,23 @@ var = variable()
 def test_between()->None:
     sql = "then if then"
     syntax = IF.between(THEN, THEN)
-    ast:AST = parse(syntax, sql, dialect='sqlite')    
-    generated = gen.generate(syntax, ast)
+    ast, bound = parse(syntax, sql, dialect='sqlite')    
+    generated, bound = gen.generate(syntax, ast)
     assert ast == generated, "Parsed and generated results do not match."
     x, f = generated.bimap()
-    assert gen.generate(syntax, f(x)) == ast
+    u, v = gen.generate(syntax, f(x))
+    assert u == ast
 
 
 def test_sep_by()->None:
     sql = "if then if then if then if"
     syntax = IF.sep_by(THEN)
-    ast:AST = parse(syntax, sql, dialect='sqlite')    
-    generated = gen.generate(syntax, ast)
+    ast, bound = parse(syntax, sql, dialect='sqlite')    
+    generated, bound = gen.generate(syntax, ast)
     assert ast == generated, "Parsed and generated results do not match."
     x, f = generated.bimap()
-    assert gen.generate(syntax, f(x)) == ast
+    u, v = gen.generate(syntax, f(x))
+    assert u == ast
 
 def test_many_or()->None:
     IF = literal("if")
@@ -35,8 +37,9 @@ def test_many_or()->None:
     END = literal("end")
     syntax = (IF.many() | THEN.many()).many() // END
     sql = "if if then end"
-    ast:AST = parse(syntax, sql, dialect='sqlite')
-    generated = gen.generate(syntax, ast)
+    ast, bound = parse(syntax, sql, dialect='sqlite')
+    generated, bound = gen.generate(syntax, ast)
     assert ast == generated, "Parsed and generated results do not match."
     x, f = generated.bimap()
-    assert gen.generate(syntax, f(x)) == ast
+    u, v = gen.generate(syntax, f(x))
+    assert u == ast

{syncraft-0.2.0 → syncraft-0.2.1}/tests/test_to.py

@@ -43,19 +43,21 @@ def test_to() -> None:
             + ifthenelse.mark('body')
             // ~END).to(While)
     sql = 'while b if a,b then c,d else a,d end if a,b then c,d else a,d end'
-    ast = parse(syntax, sql, dialect='sqlite')
+    ast, bound = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    g = gen.generate(syntax, ast, restore_pruned=True)
+    g, bound = gen.generate(syntax, ast, restore_pruned=True)
     assert ast == g
     x, f = g.bimap()
     print(1, x)
-    assert gen.generate(syntax, f(x), restore_pruned=True) == ast
+    u,v = gen.generate(syntax, f(x), restore_pruned=True)
+    assert u == ast
     x.body.append(x.body[0])
     print(2, x)
     print(f(x))
-    ast2 = gen.generate(syntax, f(x), restore_pruned=True) 
+    ast2, bound = gen.generate(syntax, f(x), restore_pruned=True) 
     print(ast2)
     y, fy = ast2.bimap()
     print(3, y)
     assert y == x
-    assert gen.generate(syntax, fy(y), restore_pruned=True) == ast2
+    u, v = gen.generate(syntax, fy(y), restore_pruned=True)
+    assert u == ast2

{syncraft-0.2.0 → syncraft-0.2.1}/tests/test_until.py

@@ -10,7 +10,7 @@ LB, RB = literal("["), literal("]")
 def test_until_accepts_proper_nesting() -> None:
     sql = "([])"
     syntax = until((LP, RP), (LB, RB))
-    ast: AST | Any = parse(syntax, sql, dialect="sqlite")
+    ast, bound = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, tuple), f"Expected AST for proper nesting, got {ast}"
 
 
@@ -18,7 +18,7 @@ def test_until_rejects_mismatched_pairs() -> None:
     # Mismatched: ( ] should fail immediately
     sql = "(]"
     syntax = until((LP, RP), (LB, RB))
-    res = parse(syntax, sql, dialect="sqlite")
+    res, bound = parse(syntax, sql, dialect="sqlite")
     from syncraft.algebra import Error
     assert isinstance(res, Error), "Mismatched pairs should be rejected with an Error"
 
@@ -26,7 +26,7 @@ def test_until_rejects_unterminated_group() -> None:
     # Unterminated: ( ... EOF
     sql = "("
     syntax = until((LP, RP))
-    res = parse(syntax, sql, dialect="sqlite")
+    res, bound = parse(syntax, sql, dialect="sqlite")
     from syncraft.algebra import Error
     assert isinstance(res, Error), "Unterminated group should be rejected with an Error"
 
@@ -35,6 +35,6 @@ def test_until_rejects_crossing_pairs() -> None:
     sql = "([)]"
     syntax = until((LP, RP), (LB, RB))
     # Use postgres dialect so [ and ] are tokenized distinctly (not as bracketed identifier)
-    res = parse(syntax, sql, dialect="postgres")
+    res, bound = parse(syntax, sql, dialect="postgres")
     from syncraft.algebra import Error
     assert isinstance(res, Error), "Crossing pairs should be rejected with an Error"