syncraft 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

syncraft/utils.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+from typing import Tuple, Any, Set, Optional
+from sqlglot.expressions import Expression
+from syncraft.syntax import Syntax
+from syncraft.algebra import  Left, Right, Error, Either, Algebra
+from syncraft.parser import ParserState, Token
+
+
+def rich_error(err: Error)->None:
+    try:
+        from rich import print
+        from rich.table import Table as RichTable
+        lst = err.to_list()
+        leaf = lst[0]
+        tbl = RichTable(title="Parser Error", show_lines=True)
+        tbl.add_column("Leaf Parser Field", style="blue")
+        tbl.add_column("Leaf Parser Value", style="yellow")
+        flds: Set[str] = set(leaf.keys())
+        for fld in sorted(flds):
+            leaf_value = leaf.get(fld, "N/A")
+            tbl.add_row(f"{fld}", f"{leaf_value}")
+        print(tbl)
+    except ImportError:
+        print(err)
+
+
+def rich_parser(p: Syntax)-> None:
+    try:
+        from rich import print
+        print("Parser Debug Information:")
+        print(repr(p))
+    except ImportError:
+        print(p)
+
+def rich_debug(this: Algebra[Any, ParserState[Any]], 
+               state: ParserState[Any], 
+               result: Either[Any, Tuple[Any, ParserState[Any]]])-> None:
+    try:
+        from rich import print
+        from rich.table import Table as RichTable
+        def value_to_str(value: Any, prefix:str='') -> str:
+            if isinstance(value, (tuple, list)):
+                if len(value) == 0:
+                    return prefix + str(value)
+                else:
+                    return '\n'.join(value_to_str(item, prefix=prefix+' - ') for item in value)
+            else:                
+                if isinstance(value, Expression):
+                    return prefix + value.sql()
+                elif isinstance(value, Token):
+                    return prefix + f"{value.token_type.name}({value.text})"
+                elif isinstance(value, Syntax):
+                    return prefix + (value.meta.name or 'N/A')
+                else:
+                    return prefix + str(value)
+
+        tbl = RichTable(title=f"Debug: {this.name}", show_lines=True)
+        tbl.add_column("Parser", style="blue")
+        tbl.add_column("Old State", style="cyan")
+        tbl.add_column("Result", style="magenta")
+        tbl.add_column("New State", style="green")
+        tbl.add_column("Consumed", style="green")
+        if isinstance(result, Left):
+            tbl.add_row(value_to_str(this), value_to_str(state), value_to_str(result.value), 'N/A', 'N/A')
+        else:
+            assert isinstance(result, Right), f"Expected result to be a Right value, got {type(result)}, {result}"
+            value, new_state = result.value
+            tbl.add_row(value_to_str(this), 
+                        value_to_str(state),
+                        value_to_str(value), 
+                        value_to_str(new_state))
+
+        print(tbl)
+    except ImportError:
+        print(this)
+        print(state)
+        print(result)
+
+
+
+
+def syntax2svg(syntax: Syntax[Any, Any]) -> Optional[str]:
+    try:
+        from railroad import Diagram, Terminal, Sequence, Choice, OneOrMore, Comment, Group, Optional as RROptional
+        def to_railroad(s: Syntax[Any, Any]):
+            meta = s.meta
+            if meta is None or meta.name is None:
+                return Terminal(str(s))
+            children = [to_railroad(p) for p in meta.parameter]
+            if meta.name in ('>>', '//', '+'):
+                assert len(children) == 2
+                return Sequence(children[0], children[1])
+            elif meta.name == '|':
+                assert len(children) == 2
+                return Choice(0, children[0], children[1])
+            elif meta.name in ('*',):
+                assert len(children) == 1
+                return OneOrMore(children[0])
+            elif meta.name in ('~',):
+                assert len(children) == 1
+                return RROptional(children[0])
+            elif meta.name.startswith('token'):
+                return Terminal(meta.name)
+            elif meta.name == "sep_by":
+                assert len(children) == 2
+                return Sequence(children[0], OneOrMore(Sequence(children[1], children[0])))
+            elif meta.name.startswith('to'):
+                assert len(children) == 1
+                return Sequence(Comment(meta.name), children[0])
+            elif meta.name.startswith('bind'):
+                assert len(children) == 1
+                return Sequence(Comment(meta.name), children[0])
+            elif meta.name.startswith('mark'):
+                assert len(children) == 1
+                return Sequence(Comment(meta.name), children[0])
+            elif meta.name.startswith('when'):
+                assert len(children) == 2
+                return Group(Choice(0, children[0], children[1]), 
+                             label="Conditional on env/config")
+            elif meta.name.startswith('success'):
+                return Terminal(meta.name)
+            elif meta.name.startswith('fail'):
+                return Terminal(meta.name)
+            elif meta.name.startswith('lazy'):
+                return Terminal(meta.name)
+            elif meta.name == 'anything':
+                return Terminal(meta.name)
+            elif meta.name == 'until':
+                return Terminal(meta.name)
+            else:
+                return Sequence(Terminal(meta.name), *(children if children else []))
+
+        diagram = Diagram(to_railroad(syntax))
+        return diagram.writeSvgString()
+    except ImportError:
+        return None
+
+def ast2svg(ast: Any) -> Optional[str]:
+    """
+    Generate SVG visualization for a Syncraft AST node using graphviz.
+    Returns SVG string or None if graphviz is not available.
+    """
+    try:
+        import graphviz
+    except ImportError:
+        return None
+
+    def node_label(node):
+        from syncraft.ast import Nothing, Marked, Choice, Many, Then, Collect, Custom, Token
+        if isinstance(node, Nothing):
+            return "Nothing"
+        elif isinstance(node, Marked):
+            return f"Marked(name={node.name})"
+        elif isinstance(node, Choice):
+            return f"Choice(kind={getattr(node.kind, 'name', node.kind)})"
+        elif isinstance(node, Many):
+            return "Many"
+        elif isinstance(node, Then):
+            return f"Then(kind={node.kind.name})"
+        elif isinstance(node, Collect):
+            return f"Collect({getattr(node.collector, '__name__', str(node.collector))})"
+        elif isinstance(node, Custom):
+            return f"Custom(meta={node.meta})"
+        elif isinstance(node, Token):
+            return f"Token({node.token_type.name}: {node.text})"
+        elif hasattr(node, '__class__'):
+            return node.__class__.__name__
+        else:
+            return str(node)
+
+    def add_nodes_edges(dot, node, parent_id=None, node_id_gen=[0]):
+        from syncraft.ast import Nothing, Marked, Choice, Many, Then, Collect, Custom, Token
+        node_id = f"n{node_id_gen[0]}"
+        node_id_gen[0] += 1
+        label = node_label(node)
+        dot.node(node_id, label)
+        if parent_id is not None:
+            dot.edge(parent_id, node_id)
+
+        # Walk children according to AST type
+        if isinstance(node, Nothing):
+            return
+        elif isinstance(node, Marked):
+            add_nodes_edges(dot, node.value, node_id, node_id_gen)
+        elif isinstance(node, Choice):
+            if node.value is not None:
+                add_nodes_edges(dot, node.value, node_id, node_id_gen)
+        elif isinstance(node, Many):
+            for child in node.value:
+                add_nodes_edges(dot, child, node_id, node_id_gen)
+        elif isinstance(node, Then):
+            add_nodes_edges(dot, node.left, node_id, node_id_gen)
+            add_nodes_edges(dot, node.right, node_id, node_id_gen)
+        elif isinstance(node, Collect):
+            add_nodes_edges(dot, node.value, node_id, node_id_gen)
+        elif isinstance(node, Custom):
+            add_nodes_edges(dot, node.value, node_id, node_id_gen)
+        # Token is a leaf
+        # For other types, try to walk __dict__ if they are dataclasses
+        elif hasattr(node, '__dataclass_fields__'):
+            for f in node.__dataclass_fields__:
+                v = getattr(node, f)
+                if isinstance(v, (list, tuple)):
+                    for item in v:
+                        if hasattr(item, '__class__'):
+                            add_nodes_edges(dot, item, node_id, node_id_gen)
+                elif hasattr(v, '__class__') and v is not node:
+                    add_nodes_edges(dot, v, node_id, node_id_gen)
+
+    dot = graphviz.Digraph(format='svg')
+    add_nodes_edges(dot, ast)
+    return dot.pipe().decode('utf-8')
+
+

syncraft/walker.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from typing import (
+    Any, Tuple, Generator as PyGenerator, TypeVar, Generic, Optional, Callable, Hashable
+)
+from dataclasses import dataclass, replace, field
+from syncraft.algebra import (
+    Algebra, Either, Right, Incomplete, Left, SyncraftError
+)
+from syncraft.ast import TokenSpec, ThenSpec, ManySpec, ChoiceSpec, LazySpec
+from syncraft.parser import TokenType
+from syncraft.constraint import Bindable, FrozenDict
+
+import re
+from syncraft.syntax import Syntax
+from syncraft.cache import Cache
+
+
+S = TypeVar('S', bound=Bindable)
+A = TypeVar('A')
+B = TypeVar('B')
+SS = TypeVar('SS', bound=Hashable)
+
+
+
+
+
+
+
+@dataclass(frozen=True)
+class WalkerState(Bindable, Generic[SS]):
+    reducer: Optional[Callable[[Any, SS], SS]] = None
+    acc: Optional[SS] = None
+    visited: frozenset = field(default_factory=frozenset)
+
+
+    def reduce(self, value: Any) -> WalkerState[SS]:
+        if self.reducer:
+            new_acc = self.reducer(value, self.acc) if self.acc is not None else value
+            return replace(self, acc=new_acc)
+        else:
+            return replace(self, acc=value)
+        
+    def visit(self, key: Hashable) -> WalkerState[SS]:
+        return replace(self, visited=self.visited | {key})
+
+
+
+
+@dataclass(frozen=True)
+class Walker(Algebra[SS, WalkerState[SS]]):
+    @classmethod
+    def state(cls, reducer: Callable[[Any, SS], SS], init: SS )->WalkerState[SS]: # type: ignore
+        assert callable(reducer), f"reducer must be a Reducer or None, got {type(reducer)}"
+        return WalkerState(reducer=reducer, acc=init)
+
+
+    @classmethod
+    def lazy(cls, thunk: Callable[[], Algebra[Any, WalkerState[SS]]], cache: Cache) -> Algebra[Any, WalkerState[SS]]:
+        def alazy_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+            result = yield from thunk().run(input, use_cache)
+            return result
+
+        def lazy_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+            print('thunk', thunk, input.visited)
+            if thunk in input.visited:
+                return Right((None, input))
+            else:
+                thunk_result = yield from thunk().run(input, use_cache)
+                match thunk_result:
+                    case Right((value, from_thunk)):
+                        data = LazySpec(value=value)
+                        return Right((data, from_thunk.visit(thunk).reduce(data)))
+            raise SyncraftError("flat_map should always return a value or an error.", offending=thunk_result, expect=(Left, Right))
+        return cls(lazy_run, name=cls.__name__ + '.lazy', cache=cache)
+
+
+    def then_both(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
+        def then_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+            self_result = yield from self.run(input, use_cache=use_cache)
+            match self_result:
+                case Right((value, from_left)):
+                    other_result = yield from other.run(from_left, use_cache)
+                    match other_result:
+                        case Right((result, from_right)):
+                            data = ThenSpec(left=value, right=result)
+                            return Right((data, from_right.reduce(data)))
+            raise SyncraftError("flat_map should always return a value or an error.", offending=self_result, expect=(Left, Right))
+        return self.__class__(then_run, name=self.name, cache=self.cache | other.cache) 
+
+    def then_left(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
+        return self.then_both(other)  # For simplicity, treat as both
+
+    def then_right(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
+        return self.then_both(other)
+
+
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Any, WalkerState[SS]]:
+        if at_least <=0 or (at_most is not None and at_most < at_least):
+            raise SyncraftError(f"Invalid arguments for many: at_least={at_least}, at_most={at_most}", offending=(at_least, at_most), expect="at_least>0 and (at_most is None or at_most>=at_least)")
+        def many_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+            self_result = yield from self.run(input, use_cache)
+            match self_result:
+                case Right((value, from_self)):
+                    data = ManySpec(value=value, at_least=at_least, at_most=at_most)
+                    return Right((data, from_self.reduce(data)))
+            raise SyncraftError("many should always return a value or an error.", offending=self_result, expect=(Left, Right))
+        return self.__class__(many_run, name=f"many({self.name})", cache=self.cache)  
+    
+ 
+    def or_else(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]: 
+        def or_else_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+            self_result = yield from self.run(input, use_cache=use_cache)
+            match self_result:
+                case Right((value, from_left)):
+                    other_result = yield from other.run(from_left, use_cache)
+                    match other_result:
+                        case Right((result, from_right)):
+                            data = ChoiceSpec(left=value, right=result)
+                            return Right((data, from_right.reduce(data)))
+            raise SyncraftError("", offending=self)
+        return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})", cache=self.cache | other.cache) 
+
+    @classmethod
+    def token(cls, 
+              *,
+              cache: Cache,
+              token_type: Optional[TokenType] = None, 
+              text: Optional[str] = None, 
+              case_sensitive: bool = False,
+              regex: Optional[re.Pattern[str]] = None
+              )-> Algebra[Any, WalkerState[SS]]:      
+        def token_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+            yield from ()
+            data = TokenSpec(token_type=token_type, text=text, regex=regex, case_sensitive=case_sensitive)
+            return Right((data, input.reduce(data)))
+        return cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})', cache=cache)  
+
+
+def walk(syntax: Syntax[Any, Any], reducer: Callable[[Any, Any], SS], init: SS)-> Optional[SS]:
+    from syncraft.syntax import run
+    from rich import print
+    v, s = run(syntax=syntax, alg=Walker, use_cache=False, reducer=reducer, init=init)
+    if s is not None:
+        return s.acc
+    else:
+        return None

syncraft-0.2.6.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: syncraft
+Version: 0.2.6
+Summary: Parser combinator library
+Author-email: Michael Afmokt <michael@esacca.com>
+License-Expression: MIT
+Keywords: parser,combinator,sql,sqlite,generator,printer
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rstr>=3.2.2
+Requires-Dist: sqlglot>=27.7.0
+Dynamic: license-file
+
+# Syncraft
+
+Syncraft is a parser/generator combinator library for Python. It helps you
+
+- Build grammars
+- Parse SQL statement to AST
+- Search AST by grammar
+- Convert AST to dataclass
+- Check constraints over the AST/dataclass
+- Change dataclass and convert back to AST
+
+
+## Installation
+
+### pip
+```bash
+pip install syncraft
+```
+
+### uv
+```bash
+uv add syncraft
+```
+
+Python 3.10+ is required.
+
+### With pip
+```bash
+pip install syncraft[dev]
+```
+
+### With uv
+```bash
+uv sync --group dev 
+```
+
+TODO
+- [ ] debug constraint.datalog
+- [ ] debug sqlite3
+- [ ] collect terminal from syntax and build PLY lexer
+- [ ] chunker
+- [ ] unify in find

syncraft-0.2.6.dist-info/RECORD

@@ -0,0 +1,20 @@
+syncraft/__init__.py,sha256=g1Rd3DwPJ-Z7dL0PBNyNkcLBmpkp8bIBDWabkeBCD48,1329
+syncraft/algebra.py,sha256=W6n4YH75VUU960DTW1ZGljmuhvOtLOzkL6_w9DG6fWI,20706
+syncraft/ast.py,sha256=kMpZtox3S41t6srptJzd8G0p7Imu-FX2reC6Zdk47PY,20779
+syncraft/cache.py,sha256=n7YpN6OmkDySVKRP-FWE8Ni6WqzMHz2b4TsSbBPRJtA,3655
+syncraft/constraint.py,sha256=a6j_VafRor8W7FBXh20DoVnIUO9nfn7eIValigCf9lU,16318
+syncraft/dev.py,sha256=v7jdb2aOVCGbio-Jw14tRhO09FkhWc0vrDdIkIKPu2Y,186
+syncraft/finder.py,sha256=Mv9BYrsDjjq62Z4NO3gElZAbkEgSBINhSbqFbKEQW4Q,4347
+syncraft/generator.py,sha256=ybliYMDCC7z_Q3ODUYvYvwaKaMl7lULtJkmtX_c6lWw,21209
+syncraft/lexer.py,sha256=npPHAEEbBRQYcFHPMHtXmiVLbCZAnjpTtj3cnVui4W0,3720
+syncraft/parser.py,sha256=jt34gkHl4OJuImedR4abPGPw0VZtSOPzuTQRsvx8G_k,10094
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=O4HE4IDZ6fclP7kRy5L6rIuIdp_LmnMsr0LRuAIIS8s,25033
+syncraft/utils.py,sha256=2V446Il2q4mR7bwwGX5_qruJPU0WXU2PniXEjl6EOPE,8746
+syncraft/walker.py,sha256=EoTSCCiaIPpBpsd6EcbFCw2_0jlDyNkemAeDoqA4Mus,7118
+syncraft-0.2.6.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.2.6.dist-info/METADATA,sha256=tFUXcscYjk8tgtahL7BPkTstoFN7o3rJgi2QL9z3y-s,1023
+syncraft-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.2.6.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.2.6.dist-info/RECORD,,

syncraft/diagnostic.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-from rich import print
-from rich.table import Table as RichTable
-from typing import Tuple, Any, Set
-from syncraft.syntax import Syntax
-from syncraft.algebra import  Left, Right, Error, Either, Algebra
-
-from syncraft.parser import ParserState, Token
-from sqlglot.expressions import Expression
-
-
-def rich_error(err: Error)->None:
-    lst = err.to_list()
-    root, leaf = lst[0], lst[-1]
-    tbl = RichTable(title="Parser Error", show_lines=True)
-    tbl.add_column("Root Parser Field", style="blue")
-    tbl.add_column("Root Parser Value", style="green")
-    tbl.add_column("...")
-    tbl.add_column("Leaf Parser Field", style="blue")
-    tbl.add_column("Leaf Parser Value", style="yellow")
-    flds: Set[str] = set(root.keys()) | set(leaf.keys())
-    for fld in sorted(flds):
-        root_value = root.get(fld, "N/A")
-        leaf_value = leaf.get(fld, "N/A")
-        tbl.add_row(f"{fld}", f"{root_value}", "...", f"{fld}", f"{leaf_value}")
-    print(tbl)
-
-
-def rich_parser(p: Syntax)-> None:
-    print("Parser Debug Information:")
-    print(p.meta.to_string(lambda _ : True) or repr(p))
-
-def rich_debug(this: Algebra[Any, ParserState[Any]], 
-               state: ParserState[Any], 
-               result: Either[Any, Tuple[Any, ParserState[Any]]])-> None:
-    def value_to_str(value: Any, prefix:str='') -> str:
-        if isinstance(value, (tuple, list)):
-            if len(value) == 0:
-                return prefix + str(value)
-            else:
-                return '\n'.join(value_to_str(item, prefix=prefix+' - ') for item in value)
-        else:                
-            if isinstance(value, Expression):
-                return prefix + value.sql()
-            elif isinstance(value, Token):
-                return prefix + f"{value.token_type.name}({value.text})"
-            elif isinstance(value, Syntax):
-                return prefix + (value.meta.to_string(lambda _ : True) or 'N/A')
-            else:
-                return prefix + str(value)
-
-    tbl = RichTable(title=f"Debug: {this.name}", show_lines=True)
-    tbl.add_column("Parser", style="blue")
-    tbl.add_column("Old State", style="cyan")
-    tbl.add_column("Result", style="magenta")
-    tbl.add_column("New State", style="green")
-    tbl.add_column("Consumed", style="green")
-    if isinstance(result, Left):
-        tbl.add_row(value_to_str(this), value_to_str(state), value_to_str(result.value), 'N/A', 'N/A')
-    else:
-        assert isinstance(result, Right), f"Expected result to be a Right value, got {type(result)}, {result}"
-        value, new_state = result.value
-        tbl.add_row(value_to_str(this), 
-                    value_to_str(state),
-                    value_to_str(value), 
-                    value_to_str(new_state), 
-                    value_to_str(state.delta(new_state)))
-
-    print(tbl)
-

syncraft-0.2.5.dist-info/METADATA

@@ -1,113 +0,0 @@
-Metadata-Version: 2.4
-Name: syncraft
-Version: 0.2.5
-Summary: Parser combinator library
-Author-email: Michael Afmokt <michael@esacca.com>
-License-Expression: MIT
-Keywords: parser,combinator,sql,sqlite,generator,printer
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: rich>=14.1.0
-Requires-Dist: rstr>=3.2.2
-Requires-Dist: sqlglot>=27.7.0
-Dynamic: license-file
-
-# Syncraft
-
-Syncraft is a parser/generator combinator library for Python. It helps you
-
-- Build grammars
-- Parse SQL statement to AST
-- Search AST by grammar
-- Convert AST to dataclass
-- Check constraints over the AST/dataclass
-- Change dataclass and convert back to AST
-
-
-## Installation
-
-### pip
-```bash
-pip install syncraft
-```
-
-### uv
-```bash
-uv add syncraft
-```
-
-Python 3.10+ is required.
-
-## Quickstart
-
-!. Define grammar 
-
-```python
-from dataclasses import dataclass
-from syncraft import literal, parse, generate
-
-A = literal("a")
-B = literal("b")
-syntax = A + B  # sequence
-
-ast, _ = parse(syntax, "a b", dialect="sqlite")
-gen, _ = generate(syntax, ast)
-assert ast == gen
-```
-
-Collect parsed pieces into dataclasses using marks and `.to()`:
-
-```python
-from dataclasses import dataclass
-from syncraft import literal
-
-@dataclass
-class Pair:
-		first: any
-		second: any
-
-A = literal("a").mark("first")
-B = literal("b").mark("second")
-syntax = (A + B).to(Pair)
-
-ast, _ = parse(syntax, "a b", dialect="sqlite")
-value, invert = ast.bimap()
-# value is Pair(first=VAR(a), second=VAR(b))
-round_tripped, _ = generate(syntax, invert(value))
-assert round_tripped == ast
-```
-
-Use the built‑in SQLite grammar snippets to parse statements:
-
-```python
-from syncraft import parse
-from syncraft.sqlite3 import select_stmt
-
-ast, _ = parse(select_stmt, "select a from t where a > 1", dialect="sqlite")
-```
-
-## Core ideas
-
-- Syntax describes structure and transforms values; Algebra executes it.
-- AST types: Then, Choice, Many, Marked, Collect, Nothing, Token.
-- Operators: `+` (both), `>>` (keep right), `//` (keep left), `|` (choice), `~` (optional), `many()`, `sep_by()`, `between()`.
-- Error model supports backtracking and commit (`cut()`).
-
-## Documentation
-
-- Tutorials and API reference are built with MkDocs. Local preview:
-	1) install dev deps (see `pyproject.toml` dev group)
-	2) activate your venv and run `mkdocs serve`
-
-- Version injection: pages can use `{{ version }}`. It is provided by mkdocs-macros via `docs/main.py`, which resolves the version in this order:
-	- `[project].version` from `pyproject.toml`
-	- installed package metadata (`importlib.metadata.version('syncraft')`)
-	- fallback `"0.0.0"`
-
-  The macros plugin is configured in `mkdocs.yml` with `module_name: docs/main`.
-
-## Contributing / Roadmap
-
-- Improve performance and add benchmarks
-- Expand tutorials and SQLite coverage examples

syncraft-0.2.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-syncraft/__init__.py,sha256=8LIO0m0XEAsgKd--G8u6uT-lljLDtKMeIequNRNv2dc,894
-syncraft/algebra.py,sha256=zm6HzaE2XeyhWInoKDSJrVtnkjJV6BsD0zPBRz7iDAI,23333
-syncraft/ast.py,sha256=F6aRdxZ6IBNvnk1xe_ugEBvL-BXNXdkN4s1YDIuNw3Y,19134
-syncraft/constraint.py,sha256=qq-DkCH-8NgGqSYrNo4achq5t4gEEycelFTJWg4I_ek,15439
-syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
-syncraft/finder.py,sha256=FCOHGdJf2NHG_letl8-IArfBywEolmtZcTJQPOj1iYw,4147
-syncraft/generator.py,sha256=bmXcnExG-M44ChxdS9K_6H0MdCa9gD7erJ8aAu-LpXM,20444
-syncraft/parser.py,sha256=9z9Iq9_Ih3mlXkuz85gsND4xshZARgAqo5-R_DpgA9I,17338
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=nSWE1SHvVDYON0UQM8kgp14kx54hbKBYHV0xB6fgwkk,22366
-syncraft-0.2.5.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.2.5.dist-info/METADATA,sha256=X4WtYQxjCWYSf3JF7UI2zyERU-NJQObI-gwTcUxzHB4,2821
-syncraft-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.2.5.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.2.5.dist-info/RECORD,,