syncraft 0.2.0__tar.gz → 0.2.2__tar.gz

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

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

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

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

{syncraft-0.2.0 → syncraft-0.2.2}/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.2}/syncraft/constraint.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass, field, replace
 import collections.abc
 from collections import defaultdict
 from itertools import product
+from inspect import Signature
 import inspect
 
 K = TypeVar('K')
@@ -122,9 +123,9 @@ class Constraint:
     def predicate(cls, 
                   f: Callable[..., bool],
                   *, 
-                  name: Optional[str] = None, 
-                  quant: Quantifier = Quantifier.FORALL)->Constraint:
-        sig = inspect.signature(f)
+                  sig: Signature,
+                  name: str, 
+                  quant: Quantifier)->Constraint:
         pos_params = []
         kw_params = []
         for pname, param in sig.parameters.items():
@@ -160,12 +161,31 @@ class Constraint:
             else:
                 return ConstraintResult(result = all(eval_combo(c) for c in all_combos), unbound=frozenset())
 
-        return cls(run_f=run_f, name=name or f.__name__)
+        return cls(run_f=run_f, name=name)
+
+
+def predicate(f: Callable[..., bool], 
+              *, 
+              name: Optional[str] = None, 
+              quant: Quantifier = Quantifier.FORALL, 
+              bimap: bool = True) -> Constraint:
+    name = name or f.__name__
+    sig = inspect.signature(f)
+    if bimap:
+        def wrapper(*args: Any, **kwargs:Any) -> bool:
+            mapped_args = [a.bimap()[0] if hasattr(a, "bimap") else a for a in args]
+            mapped_kwargs = {k: (v.bimap()[0] if hasattr(v, "bimap") else v) for k,v in kwargs.items()}
+            return f(*mapped_args, **mapped_kwargs)
+        
+        return Constraint.predicate(wrapper, sig=sig, name=name, quant=quant)
+    else:
+        return Constraint.predicate(f, sig=sig, name=name, quant=quant)
 
-def forall(f: Callable[..., bool], name: Optional[str] = None) -> Constraint:
-    return Constraint.predicate(f, name=name, quant=Quantifier.FORALL)
+def forall(f: Callable[..., bool], name: Optional[str] = None, bimap: bool=True) -> Constraint:
+    return predicate(f, name=name, quant=Quantifier.FORALL, bimap=bimap)
     
-def exists(f: Callable[..., bool], name: Optional[str] = None) -> Constraint:
-    return Constraint.predicate(f, name=name, quant=Quantifier.EXISTS)
+def exists(f: Callable[..., bool], name: Optional[str] = None, bimap:bool = True) -> Constraint:
+    return predicate(f, name=name, quant=Quantifier.EXISTS, bimap=bimap)
+
 
 

{syncraft-0.2.0 → syncraft-0.2.2}/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, Tuple[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.2}/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[T]:
+        tokens = tuple([Token(token_type=token.token_type, text=token.text) for token in tokenize(sql, dialect=dialect)])
+        return ParserState.from_tokens(tokens)  # type: ignore
+
     @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, Tuple[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.2}/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, Tuple[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.2}/syncraft.egg-info/PKG-INFO

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

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

@@ -18,8 +18,8 @@ syncraft.egg-info/dependency_links.txt
 syncraft.egg-info/requires.txt
 syncraft.egg-info/top_level.txt
 tests/test_bimap.py
+tests/test_constraint.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.2}/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.2/tests/test_constraint.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+from typing import Any, List, Tuple
+from syncraft.algebra import Either, Left, Right, Error
+from syncraft.ast import Marked, Then, ThenKind, Many, Nothing
+from syncraft.parser import literal, variable, parse, Parser, Token
+from syncraft.generator import TokenGen
+from syncraft.constraint import forall, exists
+from rich import print
+import syncraft.generator as gen
+from dataclasses import dataclass
+
+
+def test_to() -> None:
+    @dataclass
+    class IfThenElse:
+        condition: Any
+        then: Any
+        otherwise: Any
+
+    @dataclass
+    class While:
+        condition:Any
+        body:Any
+
+    WHILE = literal("while")
+    IF = literal("if")
+    ELSE = literal("else")
+    THEN = literal("then")
+    END = literal("end")
+    A = literal('a')
+    B = literal('b')
+    C = literal('c')
+    D = literal('d')
+    M = literal(',')
+    var = A | B | C | D
+    condition = var.sep_by(M).mark('condition').bind() 
+    ifthenelse = (IF >> condition
+              // THEN 
+              + var.sep_by(M).mark('then').bind() 
+              // ELSE 
+              + var.sep_by(M).mark('otherwise').bind() 
+              // END).to(IfThenElse).many()
+    syntax = (WHILE >> condition
+            + ifthenelse.mark('body').bind()
+            // ~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, bound = parse(syntax, sql, dialect='sqlite')
+    def p(condition, then, otherwise)->bool:
+        print({'condition':condition, 'then':then, 'otherwise':otherwise})
+        return True
+    if bound is not None:
+        forall(p)(bound)
+    g, bound = gen.generate(syntax, ast, restore_pruned=True)

{syncraft-0.2.0 → syncraft-0.2.2}/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.2}/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.2}/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.2}/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"