syncraft 0.1.29__tar.gz → 0.1.31__tar.gz

{syncraft-0.1.29 → syncraft-0.1.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.29
+Version: 0.1.31
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
@@ -29,8 +29,6 @@ pip install syncraft
 
 
 ## TODO
-- [ ] simplify the result of then_left and then_right by bimap the result in syntax.
-- [ ] simplify the result of sep_by and between by bimap the result in syntax
 - [ ] convert to dict/dataclass via bimap in syntax
 - [ ] define DSL over Variable to construct predicates
 - [ ] Try the parsing, generation, and data processing machinery on SQLite3 syntax. So that I can have direct feedback on the usability of this library and a fully functional SQLite3 library.

{syncraft-0.1.29 → syncraft-0.1.31}/README.md

@@ -14,8 +14,6 @@ pip install syncraft
 
 
 ## TODO
-- [ ] simplify the result of then_left and then_right by bimap the result in syntax.
-- [ ] simplify the result of sep_by and between by bimap the result in syntax
 - [ ] convert to dict/dataclass via bimap in syntax
 - [ ] define DSL over Variable to construct predicates
 - [ ] Try the parsing, generation, and data processing machinery on SQLite3 syntax. So that I can have direct feedback on the usability of this library and a fully functional SQLite3 library.

{syncraft-0.1.29 → syncraft-0.1.31}/pyproject.toml

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

{syncraft-0.1.29 → syncraft-0.1.31}/syncraft/algebra.py

@@ -5,12 +5,15 @@ from typing import (
 )
 
 import traceback
-from dataclasses import dataclass, replace, asdict
+from dataclasses import dataclass, replace
 from weakref import WeakKeyDictionary
 from abc import ABC
-from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind
+from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind, shallow_dict
 from syncraft.constraint import Bindable
 
+
+
+
 S = TypeVar('S', bound=Bindable)
     
 A = TypeVar('A')  # Result type
@@ -64,7 +67,7 @@ class Error:
         lst = []
         current: Optional[Error] = self
         while current is not None:
-            d = asdict(current)
+            d = shallow_dict(current)
             lst.append({k:v for k,v in d.items() if v is not None and k != 'previous'})
             current = current.previous
         return lst

{syncraft-0.1.29 → syncraft-0.1.31}/syncraft/ast.py

@@ -4,14 +4,20 @@ from __future__ import annotations
 import re
 from typing import (
     Optional, Any, TypeVar, Tuple, runtime_checkable, cast,
-    Generic, Callable, Union, Protocol, Type, List, ClassVar
+    Generic, Callable, Union, Protocol, Type, List, ClassVar,
+    Dict
 )
 
 
-from dataclasses import dataclass, replace, is_dataclass, asdict, fields
+from dataclasses import dataclass, replace, is_dataclass, fields
 from enum import Enum
 
 
+def shallow_dict(a: Any)->Dict[str, Any]:
+    assert is_dataclass(a), f"Expected dataclass instance for collector inverse, got {type(a)}"
+    return {f.name: getattr(a, f.name) for f in fields(a)}
+
+
 
 
 A = TypeVar('A')
@@ -287,37 +293,42 @@ class Collect(Generic[A, E], AST):
     collector: Collector
     value: A
     def bimap(self, r: Bimap[A, B]=Bimap.identity()) -> Tuple[B | E, Callable[[B | E], Collect[A, E]]]:
-        b, inner_f = r(self.value)
-        if isinstance(self.value, Then) and self.value.kind == ThenKind.BOTH:
-            assert isinstance(b, tuple), f"Expected tuple from Then.BOTH combinator, got {type(b)}"
-            index: List[str | int] = []
-            named_count = 0
-            for i, v in enumerate(b):
-                if isinstance(v, Marked):
-                    index.append(v.name)
-                    named_count += 1
-                else:
-                    index.append(i - named_count)
-            named = {v.name: v.value for v in b if isinstance(v, Marked)}
-            unnamed = [v for v in b if not isinstance(v, Marked)]
-            ret: E = self.collector(*unnamed, **named)
-            def invf(e: E) -> Tuple[Any, ...]:
-                assert is_dataclass(e), f"Expected dataclass instance for collector inverse, got {type(e)}"
-                named_dict = asdict(e)     
-                unnamed = []           
-                for f in fields(e):
-                    if f.name not in named:
-                        unnamed.append(named_dict[f.name])
-                tmp = []
-                for x in index:
-                    if isinstance(x, str):
-                        tmp.append(Marked(name=x, value=named_dict[x]))
+
+        def inv_one_positional(e: E) -> B:
+            assert is_dataclass(e), f"Expected dataclass instance for collector inverse, got {type(e)}"
+            named_dict = shallow_dict(e)
+            return named_dict[fields(e)[0].name]
+
+        b, inner_f = self.value.bimap(r) if isinstance(self.value, AST) else r(self.value) 
+        if isinstance(self.value, Then):
+            if isinstance(b, tuple):
+                index: List[str | int] = []
+                named_count = 0
+                for i, v in enumerate(b):
+                    if isinstance(v, Marked):
+                        index.append(v.name)
+                        named_count += 1
                     else:
-                        tmp.append(unnamed[x])
-                return tuple(tmp)
-            return ret, lambda e: replace(self, value=inner_f(invf(e))) # type: ignore
-        else:
-            return b, lambda e: replace(self, value=inner_f(e)) # type: ignore
+                        index.append(i - named_count)
+                named = {v.name: v.value for v in b if isinstance(v, Marked)}
+                unnamed = [v for v in b if not isinstance(v, Marked)]
+                ret: E = self.collector(*unnamed, **named)
+                def invf(e: E) -> Tuple[Any, ...]:
+                    assert is_dataclass(e), f"Expected dataclass instance for collector inverse, got {type(e)}"
+                    named_dict = shallow_dict(e)     
+                    unnamed = []           
+                    for f in fields(e):
+                        if f.name not in named:
+                            unnamed.append(named_dict[f.name])
+                    tmp = []
+                    for x in index:
+                        if isinstance(x, str):
+                            tmp.append(Marked(name=x, value=named_dict[x]))
+                        else:
+                            tmp.append(unnamed[x])
+                    return tuple(tmp)
+                return ret, lambda e: replace(self, value=inner_f(invf(e))) # type: ignore                
+        return self.collector(b), lambda e: replace(self, value=inner_f(inv_one_positional(e))) # type: ignore
 
 #########################################################################################################################
 @dataclass(frozen=True)

{syncraft-0.1.29 → syncraft-0.1.31}/syncraft/syntax.py

@@ -165,9 +165,24 @@ class Syntax(Generic[A, S]):
     def between(self, left: Syntax[B, S], right: Syntax[C, S]) -> Syntax[Then[B, Then[A, C]], S]:
         return left >> self // right
 
-    def sep_by(self, sep: Syntax[B, S]) -> Syntax[Then[A, Choice[Many[Then[B, A]], Optional[Nothing]]], S]:
+    def sep_by(self, 
+               sep: Syntax[B, S]) -> Syntax[Then[A, Choice[Many[Then[B, A]], Optional[Nothing]]], S]:
         ret: Syntax[Then[A, Choice[Many[Then[B, A]], Optional[Nothing]]], S] = (self + (sep >> self).many().optional())
-        return ret.describe( 
+        def f(a: Then[A, Choice[Many[A], Optional[Nothing]]]) -> Many[A]:
+            if a.right.kind == ChoiceKind.LEFT and isinstance(a.right.value, Many):
+                if len(a.right.value.value) == 0:
+                    return Many(value = (a.left,))
+                else:
+                    return Many(value = (a.left,) + a.right.value.value)
+            else:
+                return Many(value = (a.left,))
+        def i(a: Many[A]) -> Then[A, Choice[Many[A], Optional[Nothing]]]:
+            assert len(a.value) >= 1, f"sep_by expect at least one element, got {len(a.value)}. {a}"
+            if len(a.value) == 1:
+                return Then(kind=ThenKind.BOTH, left=a.value[0], right=Choice(kind=ChoiceKind.RIGHT, value=Nothing()))
+            else:
+                return Then(kind= ThenKind.BOTH, left=a.value[0], right=Choice(kind=ChoiceKind.LEFT, value=Many(value=a.value[1:])))
+        return ret.bimap(f,i).describe( # type: ignore
                     name='sep_by',
                     fixity='prefix',
                     parameter=(self, sep))
@@ -191,17 +206,11 @@ class Syntax(Generic[A, S]):
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         ret: Syntax[Then[A, B], S] = self.__class__(lambda cls: self.alg(cls).then_left(other.alg(cls))) # type: ignore
         return ret.describe(name=ThenKind.LEFT.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[A, B], S]) 
-
-    def __lshift__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
-        return self.__floordiv__(other)
-
+    
     def __rfloordiv__(self, other: Syntax[B, S]) -> Syntax[Then[B, A], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__floordiv__(self)
         
-    def __rlshift__(self, other: Syntax[B, S]) -> Syntax[Then[B, A], S]:
-        return self.__rfloordiv__(other)
-
     def __add__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         ret: Syntax[Then[A, B], S] = self.__class__(lambda cls: self.alg(cls).then_both(other.alg(cls))) # type: ignore
@@ -260,16 +269,16 @@ class Syntax(Generic[A, S]):
         return self.bimap(to_f, ito_f).describe(name=f'to({f})', fixity='postfix', parameter=(self,))
 
 
-    def mark(self, var: str) -> Syntax[Marked[A], S]:
+    def mark(self, name: str) -> Syntax[Marked[A], S]:
         def bind_s(value: A) -> Marked[A]:
             if isinstance(value, Marked):
-                return replace(value, name=var)    
+                return replace(value, name=name)    
             else:
-                return Marked(name=var, value=value)
+                return Marked(name=name, value=value)
         def ibind_s(m : Marked[A]) -> A:
             return m.value if isinstance(m, Marked) else m
             
-        return self.bimap(bind_s, ibind_s).describe(name=f'bind("{var}")', fixity='postfix', parameter=(self,))
+        return self.bimap(bind_s, ibind_s).describe(name=f'bind("{name}")', fixity='postfix', parameter=(self,))
 
 
 

{syncraft-0.1.29 → syncraft-0.1.31}/syncraft.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.29
+Version: 0.1.31
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
@@ -29,8 +29,6 @@ pip install syncraft
 
 
 ## TODO
-- [ ] simplify the result of then_left and then_right by bimap the result in syntax.
-- [ ] simplify the result of sep_by and between by bimap the result in syntax
 - [ ] convert to dict/dataclass via bimap in syntax
 - [ ] define DSL over Variable to construct predicates
 - [ ] Try the parsing, generation, and data processing machinery on SQLite3 syntax. So that I can have direct feedback on the usability of this library and a fully functional SQLite3 library.

{syncraft-0.1.29 → syncraft-0.1.31}/tests/test_bimap.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from syncraft.ast import Then, ThenKind, Many, Choice, ChoiceKind, Token
+from syncraft.ast import Then, ThenKind, Many, Choice, ChoiceKind, Token, Marked, Nothing
 from syncraft.algebra import Error
 from syncraft.parser import literal, parse
 import syncraft.generator as gen
@@ -19,9 +19,9 @@ def test1_simple_then() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    # value, bmap = generated.bimap()
-    # print(value)
-    # assert bmap(value) == generated
+    value, bmap = generated.bimap()
+    print(value)
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 def test2_named_results() -> None:
@@ -35,10 +35,9 @@ def test2_named_results() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    # value, bmap = generated.bimap()
-    # print(value)
-    # print(bmap(value))
-    # assert bmap(value) == generated
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
+    
 
 
 def test3_many_literals() -> None:
@@ -52,9 +51,8 @@ def test3_many_literals() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    # value, bmap = generated.bimap()
-    # print(value)
-    # assert bmap(value) == generated
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 def test4_mixed_many_named() -> None:
@@ -69,9 +67,8 @@ def test4_mixed_many_named() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    # value, bmap = generated.bimap()
-    # print(value)
-    # assert bmap(value) == generated
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 def test5_nested_then_many() -> None:
@@ -85,9 +82,8 @@ def test5_nested_then_many() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    # value, bmap = generated.bimap()
-    # print(value)
-    # assert bmap(value) == generated
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value), restore_pruned=True) == generated
 
 
 
@@ -99,8 +95,8 @@ def test_then_flatten():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    # value, bmap = ast.bimap()
-    # assert bmap(value) == ast    
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 
@@ -114,11 +110,8 @@ def test_named_in_then():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    # value, bmap = ast.bimap()
-    # assert isinstance(value, tuple)
-    # print(value)
-    # assert set(x.name for x in value if isinstance(x, Marked)) == {"first", "second", "third"}
-    # assert bmap(value) == ast
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 def test_named_in_many():
@@ -129,10 +122,8 @@ def test_named_in_many():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    # value, bmap = ast.bimap()
-    # assert isinstance(value, list)
-    # assert all(isinstance(v, Marked) for v in value if isinstance(v, Marked))
-    # assert bmap(value) == ast
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 def test_named_in_or():
@@ -144,10 +135,8 @@ def test_named_in_or():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    # value, bmap = ast.bimap()
-    # assert isinstance(value, Marked)
-    # assert value.name == "b"
-    # assert bmap(value) == ast    
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 
@@ -165,8 +154,8 @@ def test_deep_mix():
     print('---' * 40)
     print(generated)
     assert ast == generated
-    # value, bmap = ast.bimap()
-    # assert bmap(value) == ast
+    value, bmap = generated.bimap()
+    assert gen.generate(syntax, bmap(value)) == generated
 
 
 def test_empty_many() -> None:
@@ -183,8 +172,8 @@ def test_backtracking_many() -> None:
     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")
-    # value, bmap = ast.bimap()
-    # assert value[-1] == TokenGen.from_string("b")
+    value, bmap = ast.bimap()
+    assert gen.generate(syntax, bmap(value)) == ast
 
 def test_deep_nesting() -> None:
     A = literal("a")
@@ -209,9 +198,8 @@ def test_named_many() -> None:
     syntax = A.many()
     sql = "a a"
     ast = parse(syntax, sql, dialect="sqlite")
-    # Expect [Marked("alpha", "a"), Marked("alpha", "a")]
-    # flattened, _ = ast.bimap()
-    # assert all(isinstance(x, Marked) for x in flattened)
+    value, bmap = ast.bimap()
+    assert gen.generate(syntax, bmap(value)) == ast
 
 
 def test_or_named() -> None:
@@ -220,10 +208,8 @@ def test_or_named() -> None:
     syntax = A | B
     sql = "b"
     ast = parse(syntax, sql, dialect="sqlite")
-    # Either Marked("y", "b") or just "b", depending on your design
-    # assert isinstance(ast, Choice)
-    # value, _ = ast.bimap()
-    # assert value == Marked(name="y", value=TokenGen.from_string("b"))
+    value, bmap = ast.bimap()
+    assert gen.generate(syntax, bmap(value)) == ast
 
 
 def test_then_associativity() -> None:
@@ -269,11 +255,11 @@ def test_optional():
     A = literal("a").mark("a")
     syntax = A.optional()
     ast1 = parse(syntax, "", dialect="sqlite")
-    # v1, _ = ast1.bimap()
-    # assert v1 is None
-    # ast2 = parse(syntax, "a", dialect="sqlite")
-    # v2, _ = ast2.bimap()
-    # assert v2 == Marked(name='a', value=TokenGen.from_string('a'))
+    v1, _ = ast1.bimap()
+    assert isinstance(v1, Nothing)
+    ast2 = parse(syntax, "a", dialect="sqlite")
+    v2, _ = ast2.bimap()
+    assert v2 == Marked(name='a', value=TokenGen.from_string('a'))
 
 
 

{syncraft-0.1.29 → syncraft-0.1.31}/tests/test_parse.py

@@ -16,6 +16,8 @@ def test_between()->None:
     ast:AST = parse(syntax, sql, dialect='sqlite')    
     generated = 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
 
 
 def test_sep_by()->None:
@@ -24,6 +26,8 @@ def test_sep_by()->None:
     ast:AST = parse(syntax, sql, dialect='sqlite')    
     generated = 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
 
 def test_many_or()->None:
     IF = literal("if")
@@ -34,3 +38,5 @@ def test_many_or()->None:
     ast:AST = parse(syntax, sql, dialect='sqlite')
     generated = 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