syncraft 0.2.1__tar.gz → 0.2.2__tar.gz

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

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

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

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

{syncraft-0.2.1 → 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.1 → syncraft-0.2.2}/syncraft/generator.py

@@ -297,7 +297,7 @@ 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) -> Tuple[AST, FrozenDict[str, AST]] | Tuple[Any, None]:
+            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.1 → syncraft-0.2.2}/syncraft/parser.py

@@ -69,9 +69,9 @@ class ParserState(Bindable, Generic[T]):
 @dataclass(frozen=True)
 class Parser(Algebra[T, ParserState[T]]):
     @classmethod
-    def state(cls, sql: str, dialect: str) -> ParserState[Token]:
+    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) 
+        return ParserState.from_tokens(tokens)  # type: ignore
 
     @classmethod
     def token(cls, 
@@ -188,7 +188,7 @@ 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) -> Tuple[AST, FrozenDict[str, AST]] | Tuple[Any, None]:
+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)
 

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

@@ -319,7 +319,7 @@ 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 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]:
+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:

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

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

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

@@ -18,6 +18,7 @@ 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

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)