syncraft 0.1.21__py3-none-any.whl → 0.1.24__py3-none-any.whl

syncraft/algebra.py

@@ -5,200 +5,15 @@ from typing import (
 )
 
 import traceback
-from dataclasses import dataclass, replace
+from dataclasses import dataclass, replace, asdict
 from weakref import WeakKeyDictionary
 from abc import ABC
-from enum import Enum
-from functools import reduce
-
-
-A = TypeVar('A')  
-B = TypeVar('B')  
-C = TypeVar('C')  
-S = TypeVar('S')  
-
-
-@dataclass(frozen=True)
-class Bimap(Generic[S, A, B]):
-    forward: Callable[[S, A], Tuple[S, B]]
-    inverse: Callable[[S, B], Tuple[S, A]]
-    def __rshift__(self, other: Bimap[S, B, C]) -> Bimap[S, A, C]:
-        def fwd(s: S, a: A) -> Tuple[S, C]:
-            s1, b = self.forward(s, a)
-            return other.forward(s1, b)
-        def inv(s: S, c: C) -> Tuple[S, A]:
-            s1, b = other.inverse(s, c)
-            return self.inverse(s1, b)
-        return Bimap(
-            forward=fwd,
-            inverse=inv
-        )
-    @staticmethod
-    def identity()->Bimap[S, A, A]:
-        return Bimap(
-            forward=lambda s, x: (s, x),
-            inverse=lambda s, y: (s, y)
-        )
-            
-    @staticmethod
-    def when(condition: Callable[..., bool], 
-             then: Bimap[S, A, B], 
-             otherwise: Optional[Bimap[S, A, B]] = None) -> Callable[..., Bimap[S, A, B]]:
-        def _when(*args:Any, **kwargs:Any) -> Bimap[S, A, B]:
-            return then if condition(*args, **kwargs) else (otherwise or Bimap.identity())
-        return _when
+from syncraft.ast import ThenKind, ThenResult, ManyResult, OrResult, S
     
+A = TypeVar('A')  # Result type
+B = TypeVar('B')  # Mapped result type
+
 
-    
-class StructuralResult:
-    def bimap(self, 
-              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
-              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()
-              ) -> Bimap[Any, Any, Any]:
-        return Bimap.identity()
-        
-@dataclass(frozen=True)
-class NamedResult(Generic[A], StructuralResult):
-    name: str
-    value: A
-    def bimap(self, 
-              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
-              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()
-              ) -> Bimap[Any, NamedResult[A], NamedResult[Any]]:
-        inner_b = self.value.bimap(before, after) if isinstance(self.value, StructuralResult) else before(self.value) >> after(self.value)
-        def fwd(s: S, a: NamedResult[A])-> Tuple[S, NamedResult[Any]]:
-            assert a == self, f"Expected {self}, got {a}"
-            inner_s, inner_v = inner_b.forward(s, a.value)
-            return (inner_s, replace(a, value=inner_v)) if not isinstance(inner_v, NamedResult) else (inner_s, inner_v)
-        
-        def inv(s: S, a: NamedResult[Any]) -> Tuple[S, NamedResult[A]]:
-            assert isinstance(a, NamedResult), f"Expected NamedResult, got {type(a)}"
-            inner_s, inner_v = inner_b.inverse(s, a.value)
-            return (inner_s, replace(self, value=inner_v)) if not isinstance(inner_v, NamedResult) else (inner_s, replace(self, value=inner_v.value))
-        ret: Bimap[Any, Any, Any]  = Bimap(
-            forward=fwd,
-            inverse=inv
-        )    
-        return before(self) >> ret >> after(self)
-@dataclass(eq=True, frozen=True)
-class ManyResult(Generic[A], StructuralResult):
-    value: Tuple[A, ...]
-    def bimap(self, 
-              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
-              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()
-              ) -> Bimap[Any, ManyResult[A], List[A]]:
-        # We don't allow zero length ManyResult e.g. many(at_least >= 1) at the syntax level
-        # so inner_b has at least 1 element
-        assert len(self.value) > 0, "ManyResult must have at least one element"
-        inner_b = [v.bimap(before, after) if isinstance(v, StructuralResult) else before(v) >> after(v) for v in self.value]
-        def fwd(s: Any, a: ManyResult[A]) -> Tuple[Any, List[A]]:
-            assert a == self, f"Expected {self}, got {a}"
-            return s, [inner_b[i].forward(s, v)[1] for i, v in enumerate(a.value)]
-            
-        def inv(s: Any, a: List[A]) -> Tuple[Any, ManyResult[A]]:
-            assert isinstance(a, list), f"Expected list, got {type(a)}"
-            ret = [inner_b[i].inverse(s, v)[1] for i, v in enumerate(a)]
-            if len(ret) <= len(inner_b):
-                return s, ManyResult(value=tuple(ret))
-            else:
-                extra = [inner_b[-1].inverse(s, v)[1] for v in a[len(inner_b):]]
-                return s, ManyResult(value=tuple(ret + extra))
-
-        ret = Bimap(
-            forward=fwd,
-            inverse=inv
-        )    
-        return before(self) >> ret >> after(self)
-
-@dataclass(eq=True, frozen=True)
-class OrResult(Generic[A], StructuralResult):
-    value: A
-    def bimap(self, 
-              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
-              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()              
-              ) -> Bimap[Any, OrResult[A], Any]:
-        inner_b = self.value.bimap(before, after) if isinstance(self.value, StructuralResult) else before(self.value) >> after(self.value)
-        def fwd(s: Any, a: OrResult[A]) -> Tuple[Any, Any]:
-            assert a == self, f"Expected {self}, got {a}"
-            return inner_b.forward(s, a.value)
-        
-        def inv(s: Any, a: Any) -> Tuple[Any, OrResult[A]]:
-            inner_s, inner_v = inner_b.inverse(s, a)
-            return inner_s, OrResult(value=inner_v) 
-        
-        ret = Bimap(
-            forward=fwd,
-            inverse=inv
-        )    
-        return before(self) >> ret >> after(self)
-class ThenKind(Enum):
-    BOTH = '+'
-    LEFT = '//'
-    RIGHT = '>>'
-    
-@dataclass(eq=True, frozen=True)
-class ThenResult(Generic[A, B], StructuralResult):
-    kind: ThenKind
-    left: A
-    right: B
-    def arity(self)->int:
-        if self.kind == ThenKind.LEFT:
-            return self.left.arity() if isinstance(self.left, ThenResult) else 1
-        elif self.kind == ThenKind.RIGHT:
-            return self.right.arity() if isinstance(self.right, ThenResult) else 1
-        elif self.kind == ThenKind.BOTH:
-            left_arity = self.left.arity() if isinstance(self.left, ThenResult) else 1
-            right_arity = self.right.arity() if isinstance(self.right, ThenResult) else 1
-            return left_arity + right_arity
-        else:
-            return 1
-                
-    def bimap(self, 
-              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
-              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()            
-              ) -> Bimap[Any, ThenResult[A, B], Tuple[Any, ...] | Any]:
-        kind = self.kind
-        lb = self.left.bimap(before, after) if isinstance(self.left, StructuralResult) else before(self.left) >> after(self.left)
-        rb = self.right.bimap(before, after) if isinstance(self.right, StructuralResult) else before(self.right) >> after(self.right)
-        left_size = self.left.arity() if isinstance(self.left, ThenResult) else 1
-        right_size = self.right.arity() if isinstance(self.right, ThenResult) else 1
-        def fwd(s : S, a : ThenResult[A, B]) -> Tuple[S, Tuple[Any, ...] | Any]:
-            assert a == self, f"Expected {self}, got {a}"
-            match kind:
-                case ThenKind.LEFT:
-                    return lb.forward(s, a.left)
-                case ThenKind.RIGHT:
-                    return rb.forward(s, a.right)
-                case ThenKind.BOTH:
-                    s1, left_v = lb.forward(s, a.left)
-                    s2, right_v = rb.forward(s1, a.right)
-                    left_v = (left_v,) if not isinstance(a.left, ThenResult) else left_v
-                    right_v = (right_v,) if not isinstance(a.right, ThenResult) else right_v
-                    return s2, left_v + right_v
-
-        def inv(s: S, b: Tuple[Any, ...] | Any) -> Tuple[S, ThenResult[A, B]]:
-            match kind:
-                case ThenKind.LEFT:
-                    s1, lv = lb.inverse(s, b)
-                    return s1, replace(self, left=lv)
-                case ThenKind.RIGHT:
-                    s1, rv = rb.inverse(s, b)
-                    return s1, replace(self, right=rv)
-                case ThenKind.BOTH:
-                    lraw = b[:left_size]
-                    rraw = b[left_size:left_size + right_size]
-                    lraw = lraw[0] if left_size == 1 else lraw
-                    rraw = rraw[0] if right_size == 1 else rraw
-                    s1, lv = lb.inverse(s, lraw)
-                    s2, rv = rb.inverse(s1, rraw)
-                    return s2, replace(self, left=lv, right=rv)
-            
-        ret: Bimap[Any, Any, Any] = Bimap(
-            forward=fwd,
-            inverse=inv
-        )
-        return before(self) >> ret >> after(self)
-    
 InProgress = object()  # Marker for in-progress state, used to prevent re-entrance in recursive calls
 L = TypeVar('L')  # Left type for combined results
 R = TypeVar('R')  # Right type for combined results
@@ -242,7 +57,14 @@ class Error:
             state=state,
             previous=self
         )
-
+    def to_list(self)->List[Dict[str, Any]]:
+        lst = []
+        current: Optional[Error] = self
+        while current is not None:
+            d = asdict(current)
+            lst.append({k:v for k,v in d.items() if v is not None and k != 'previous'})
+            current = current.previous
+        return lst
 
 
 @dataclass(frozen=True)        
@@ -423,6 +245,12 @@ class Algebra(ABC, Generic[A, S]):
                 return cast(Either[Any, Tuple[B, S]], parsed)
         return self.__class__(map_run, name=self.name)  # type: ignore
 
+    def map_all(self, f: Callable[[Either[Any, Tuple[A, S]]], Either[Any, Tuple[B, S]]])->Algebra[B, S]:
+        def map_all_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
+            parsed = self.run(input, use_cache)
+            return f(parsed)
+        return self.__class__(map_all_run, name=self.name) # type: ignore
+
     def map_error(self, f: Callable[[Optional[Any]], Any]) -> Algebra[A, S]:
         def map_error_run(input: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
             parsed = self.run(input, use_cache)

syncraft/ast.py

@@ -4,15 +4,224 @@ from __future__ import annotations
 import re
 from typing import (
     Optional, Any, TypeVar, Tuple, runtime_checkable, 
-    Protocol, Generic, Callable, Union, cast
-)
-from syncraft.algebra import (
-    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult
+    Dict, Generic, Callable, Union, cast, List, Protocol, Type
 )
+
+
 from dataclasses import dataclass, replace, is_dataclass, asdict
 from enum import Enum
 from functools import cached_property
+from syncraft.constraint import Binding, Variable, Bindable
+
+
+
+A = TypeVar('A')
+B = TypeVar('B')  
+C = TypeVar('C')  
+S = TypeVar('S', bound=Bindable)  
+
+@dataclass(frozen=True)
+class Reducer(Generic[A, S]):
+    run_f: Callable[[A, S], S]
+    def __call__(self, a: A, s: S) -> S:
+        return self.run_f(a, s)
+    
+    def map(self, f: Callable[[B], A]) -> Reducer[B, S]:
+        def map_run(b: B, s: S) -> S:
+            return self(f(b), s)
+        return Reducer(map_run)
+    
+
+    
+@dataclass(frozen=True)
+class Bimap(Generic[A, B]):
+    run_f: Callable[[A], Tuple[B, Callable[[B], A]]]
+    def __call__(self, a: A) -> Tuple[B, Callable[[B], A]]:
+        return self.run_f(a)    
+    def __rshift__(self, other: Bimap[B, C]) -> Bimap[A, C]:
+        def then_run(a: A) -> Tuple[C, Callable[[C], A]]:
+            b, inv1 = self(a)
+            c, inv2 = other(b)
+            def inv(c2: C) -> A:
+                return inv1(inv2(c2))
+            return c, inv
+        return Bimap(then_run)
+    @staticmethod
+    def const(a: B)->Bimap[B, B]:
+        return Bimap(lambda _: (a, lambda b: b))
+
+    @staticmethod
+    def identity()->Bimap[Any, Any]:
+        return Bimap(lambda a: (a, lambda b: b))
+
+    @staticmethod
+    def when(cond: Callable[[A], bool],
+             then: Bimap[A, B],
+             otherwise: Optional[Bimap[A, C]] = None) -> Bimap[A, A | B | C]:
+        def when_run(a:A) -> Tuple[A | B | C, Callable[[A | B | C], A]]:
+            bimap = then if cond(a) else (otherwise if otherwise is not None else Bimap.identity())
+            abc, inv = bimap(a)
+            def inv_f(b: Any) -> A:
+                return inv(b)
+            return abc, inv_f
+        return Bimap(when_run)
+    
+    
+
+@dataclass(frozen=True)
+class Biarrow(Generic[S, A, B]):
+    forward: Callable[[S, A], Tuple[S, B]]
+    inverse: Callable[[S, B], Tuple[S, A]]
+    def __rshift__(self, other: Biarrow[S, B, C]) -> Biarrow[S, A, C]:
+        def fwd(s: S, a: A) -> Tuple[S, C]:
+            s1, b = self.forward(s, a)
+            return other.forward(s1, b)
+        def inv(s: S, c: C) -> Tuple[S, A]:
+            s1, b = other.inverse(s, c)
+            return self.inverse(s1, b)
+        return Biarrow(
+            forward=fwd,
+            inverse=inv
+        )
+    @staticmethod
+    def identity()->Biarrow[S, A, A]:
+        return Biarrow(
+            forward=lambda s, x: (s, x),
+            inverse=lambda s, y: (s, y)
+        )
+            
+    @staticmethod
+    def when(condition: Callable[..., bool], 
+             then: Biarrow[S, A, B], 
+             otherwise: Optional[Biarrow[S, A, B]] = None) -> Callable[..., Biarrow[S, A, B]]:
+        def _when(*args:Any, **kwargs:Any) -> Biarrow[S, A, B]:
+            return then if condition(*args, **kwargs) else (otherwise or Biarrow.identity())
+        return _when
+    
+
+    
+class StructuralResult:
+
+    def bimap(self, f: Bimap[Any, Any]=Bimap.identity())->Tuple[Any, Callable[[Any], Any]]:
+        return f(self)
+
+    
+@dataclass(frozen=True)
+class MarkedResult(Generic[A], StructuralResult):
+    name: str
+    value: A
+    def bimap(self, f: Bimap[A, B]=Bimap.identity())->Tuple[MarkedResult[B], Callable[[MarkedResult[B]], MarkedResult[A]]]:
+        b, inv = self.value.bimap(f) if isinstance(self.value, StructuralResult) else f(self.value)
+        return MarkedResult(name=self.name, value=b), lambda b: replace(self, value=inv(b.value))
+
+
+@dataclass(eq=True, frozen=True)
+class ManyResult(Generic[A], StructuralResult):
+    value: Tuple[A, ...]
+    def bimap(self, f: Bimap[A, B]=Bimap.identity())->Tuple[List[B], Callable[[List[B]], ManyResult[A]]]:
+        assert self.value
+        forward = [v.bimap(f) if isinstance(v, StructuralResult) else f(v) for v in self.value]
+        def invf(b: List[B]) -> ManyResult[A]:
+            assert len(b) <= len(forward)
+            return replace(self, value=tuple([forward[i][1](bb) for i, bb in enumerate(b)]))
+        return [b for b, _ in forward], invf
+
+
+
+@dataclass(eq=True, frozen=True)
+class OrResult(Generic[A], StructuralResult):
+    value: A
+    def bimap(self, f: Bimap[A, B]=Bimap.identity())->Tuple[B, Callable[[B], OrResult[A]]]:
+        b, inv = self.value.bimap(f) if isinstance(self.value, StructuralResult) else f(self.value)
+        return b, lambda b: replace(self, value=inv(b))
+
+class ThenKind(Enum):
+    BOTH = '+'
+    LEFT = '//'
+    RIGHT = '>>'
+    
+FlatThen = Tuple[Any, ...]
+MarkedThen = Tuple[Dict[str, Any] | Any, FlatThen]
+
+@dataclass(eq=True, frozen=True)
+class ThenResult(Generic[A, B], StructuralResult):
+    kind: ThenKind
+    left: A
+    right: B
+    @staticmethod
+    def collect_marked(a: FlatThen, f: Optional[Callable[..., Any]] = None)->Tuple[MarkedThen, Callable[[MarkedThen], FlatThen]]:
+        index: List[str | int] = []
+        named_count = 0
+        for i, v in enumerate(a):
+            if isinstance(v, MarkedResult):
+                index.append(v.name)
+                named_count += 1
+            else:
+                index.append(i - named_count)
+        named = {v.name: v.value for v in a if isinstance(v, MarkedResult)}
+        unnamed = [v for v in a if not isinstance(v, MarkedResult)]
+        if f is None:
+            ret = (named, tuple(unnamed))
+        else:
+            ret = (f(**named), tuple(unnamed))
+        def invf(b: MarkedThen) -> Tuple[Any, ...]:
+            named_value, unnamed_value = b 
+            assert isinstance(named_value, dict) or is_dataclass(named_value), f"Expected dict or dataclass for named values, got {type(named_value)}"
+            if is_dataclass(named_value):
+                named_dict = named | asdict(cast(Any, named_value))    
+            else:
+                named_dict = named | named_value
+            ret = []
+            for x in index:
+                if isinstance(x, str):
+                    assert x in named_dict, f"Missing named value: {x}"
+                    ret.append(named_dict[x])
+                else:
+                    assert 0 <= x < len(unnamed_value), f"Missing unnamed value at index: {x}"
+                    ret.append(unnamed_value[x])
+            return tuple(ret)
+        return ret, invf
+
+    def bimap(self, f: Bimap[Any, Any]=Bimap.identity()) -> Tuple[MarkedThen, Callable[[MarkedThen], ThenResult[A, B]]]:
+        match self.kind:
+            case ThenKind.LEFT:
+                lb, linv = self.left.bimap(f) if isinstance(self.left, StructuralResult) else f(self.left)
+                return lb, lambda b: replace(self, left=linv(b))
+            case ThenKind.RIGHT:
+                rb, rinv = self.right.bimap(f) if isinstance(self.right, StructuralResult) else f(self.right)
+                return rb, lambda b: replace(self, right=rinv(b))
+            case ThenKind.BOTH:
+                lb, linv = self.left.bimap(f) if isinstance(self.left, StructuralResult) else f(self.left)
+                rb, rinv = self.right.bimap(f) if isinstance(self.right, StructuralResult) else f(self.right)
+                left_v = (lb,) if not isinstance(self.left, ThenResult) else lb
+                right_v = (rb,) if not isinstance(self.right, ThenResult) else rb
+                def invf(b: Tuple[Any, ...]) -> ThenResult[A, B]:
+                    left_size = self.left.arity() if isinstance(self.left, ThenResult) else 1
+                    right_size = self.right.arity() if isinstance(self.right, ThenResult) else 1
+                    lraw = b[:left_size]
+                    rraw = b[left_size:left_size + right_size]
+                    lraw = lraw[0] if left_size == 1 else lraw
+                    rraw = rraw[0] if right_size == 1 else rraw
+                    la = linv(lraw)
+                    ra = rinv(rraw)
+                    return replace(self, left=la, right=ra)
+                return left_v + right_v, invf
+                # data, func = ThenResult.collect_marked(left_v + right_v)
+                # return data, lambda d: invf(func(d))
+
 
+    def arity(self)->int:
+        if self.kind == ThenKind.LEFT:
+            return self.left.arity() if isinstance(self.left, ThenResult) else 1
+        elif self.kind == ThenKind.RIGHT:
+            return self.right.arity() if isinstance(self.right, ThenResult) else 1
+        elif self.kind == ThenKind.BOTH:
+            left_arity = self.left.arity() if isinstance(self.left, ThenResult) else 1
+            right_arity = self.right.arity() if isinstance(self.right, ThenResult) else 1
+            return left_arity + right_arity
+        else:
+            return 1
+        
 @runtime_checkable
 class TokenProtocol(Protocol):
     @property
@@ -55,11 +264,14 @@ T = TypeVar('T', bound=TokenProtocol)
 
 ParseResult = Union[
     ThenResult['ParseResult[T]', 'ParseResult[T]'], 
-    NamedResult['ParseResult[T]'],
+    MarkedResult['ParseResult[T]'],
     ManyResult['ParseResult[T]'],
     OrResult['ParseResult[T]'],
     T,
 ]
+
+
+
 @dataclass(frozen=True)
 class AST(Generic[T]):
     focus: ParseResult[T]
@@ -68,24 +280,20 @@ class AST(Generic[T]):
 
     def bimap(self)->Tuple[Any, Callable[[Any], AST[T]]]:
         if isinstance(self.focus, StructuralResult):
-            b = self.focus.bimap() 
-            s, v = b.forward(None, self.focus)
-            def inverse(data: Any) -> AST[T]:
-                s1, v1 = b.inverse(None, data)
-                return replace(self, focus=v1)
-            return v, inverse
+            data, invf = self.focus.bimap()
+            return data, lambda x: replace(self, focus=invf(x))
         else:
             return self.focus, lambda x: replace(self, focus=x)
         
     def wrapper(self)-> Callable[[Any], Any]:
-        if isinstance(self.focus, NamedResult):
-            focus = cast(NamedResult[Any], self.focus)
-            return lambda x: NamedResult(name = focus.name, value = x)
+        if isinstance(self.focus, MarkedResult):
+            focus = cast(MarkedResult[Any], self.focus)
+            return lambda x: MarkedResult(name = focus.name, value = x)
         else:
             return lambda x: x
         
     def is_named(self) -> bool: 
-        return isinstance(self.focus, NamedResult)
+        return isinstance(self.focus, MarkedResult)
 
     def left(self) -> Optional[AST[T]]:
         match self.focus:
@@ -114,13 +322,13 @@ class AST(Generic[T]):
                     return replace(self, focus=value, parent=self, pruned=self.pruned)
                 else:
                     raise IndexError(f"Index {index} out of bounds for OrResult")
-            case NamedResult(value=value):
+            case MarkedResult(value=value):
                 return replace(self, focus=value, parent=self, pruned=self.pruned)
             case _:
                 raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
 
     def how_many(self)->int:
-        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        focus = self.focus.value if isinstance(self.focus, MarkedResult) else self.focus
         match focus:
             case ManyResult(value=children):
                 return len(children)

syncraft/constraint.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+from typing import Callable, Generic, Tuple, TypeVar, Optional, Any, Protocol
+from enum import Enum
+from dataclasses import dataclass, field, replace
+import collections.abc
+from collections import defaultdict
+from itertools import product
+
+K = TypeVar('K')
+V = TypeVar('V')
+class FrozenDict(collections.abc.Mapping, Generic[K, V]):
+    def __init__(self, *args, **kwargs):
+        self._data = dict(*args, **kwargs)
+        self._hash = None
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __len__(self):
+        return len(self._data)
+        
+    def __hash__(self):
+        if self._hash is None:
+            self._hash = hash(frozenset(self._data.items()))
+        return self._hash
+
+    def __eq__(self, other):
+        if isinstance(other, collections.abc.Mapping):
+            return self._data == other
+        return NotImplemented
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._data})"
+
+
+
+
+@dataclass(frozen=True)
+class Expr:
+    left: Any
+    op: str
+    right: Any
+
+
+@dataclass(frozen=True)
+class Variable:
+    name: Optional[str] = None
+    _root: Optional[Variable] = field(default=None, compare=False, repr=False)
+    _mapf: Optional[Callable[[Any], Any]] = field(default=None, compare=False, repr=False)
+
+    def __post_init__(self):
+        if self._root is None:
+            object.__setattr__(self, '_root', self)
+
+    def raw(self, b:'BoundVar') -> Tuple[Any, ...]:
+        assert self._root is not None, "_rawf can not be None"
+        return b.get(self._root, ())
+    
+
+    def map(self, f: Callable[[Any], Any]) -> "Variable":
+        if self._mapf is None:
+            return replace(self, _mapf=f)
+        else:
+            oldf = self._mapf
+            return replace(self, _mapf=lambda a: f(oldf(a)))
+    
+    def get(self, b: 'BoundVar') -> Tuple[Any, ...]:
+        vals = self.raw(b)
+        if self._mapf is not None:
+            return tuple(self._mapf(v) for v in vals)
+        else:
+            return vals
+        
+    def __call__(self, b:'BoundVar', raw:bool=False) -> Any:
+        if raw:
+            return self.raw(b)
+        else:
+            return self.get(b)
+        
+    def __eq__(self, other): 
+        return Expr(self, '==', other)
+    def __ne__(self, other): 
+        return Expr(self, '!=', other)
+    def __lt__(self, other): 
+        return Expr(self, '<', other)
+    def __le__(self, other): 
+        return Expr(self, '<=', other)
+    def __gt__(self, other): 
+        return Expr(self, '>', other)
+    def __ge__(self, other): 
+        return Expr(self, '>=', other)    
+
+BoundVar = FrozenDict[Variable, Tuple[Any, ...]]
+
+
+@dataclass(frozen=True)
+class Binding:
+    bindings : frozenset[Tuple[Variable, Any]] = frozenset()
+    def bind(self, var: Variable, node: Any) -> Binding:
+        new_binding = set(self.bindings)
+        new_binding.add((var, node))
+        return Binding(bindings=frozenset(new_binding))
+    
+    def to_dict(self)->BoundVar:
+        ret = defaultdict(list)
+        for var, node in self.bindings:
+            ret[var].append(node)
+        return FrozenDict({k: tuple(vs) for k, vs in ret.items()})
+
+class Bindable(Protocol):
+    binding: Binding
+    def bind(self, var: Variable, node: Any) -> Any: ...
+
+
+class Quantifier(Enum):
+    FORALL = "forall"
+    EXISTS = "exists"
+
+@dataclass(frozen=True)
+class Constraint:
+    run_f: Callable[[BoundVar], bool]
+    name: str = ""
+    def __call__(self, bound: BoundVar)->bool:
+        return self.run_f(bound)
+    def __and__(self, other: Constraint) -> Constraint:
+        return Constraint(
+            run_f=lambda bound: self(bound) and other(bound),
+            name=f"({self.name} && {other.name})"
+        )
+    def __or__(self, other: Constraint) -> Constraint:
+        return Constraint(
+            run_f=lambda bound: self(bound) or other(bound),
+            name=f"({self.name} || {other.name})"
+        )
+    def __xor__(self, other: Constraint) -> Constraint:
+        return Constraint(
+            run_f=lambda bound: self(bound) ^ other(bound),
+            name=f"({self.name} ^ {other.name})"
+        )
+    def __invert__(self) -> Constraint:
+        return Constraint(
+            run_f=lambda bound: not self(bound),
+            name=f"!({self.name})"
+        )        
+
+    @classmethod
+    def predicate(cls, f: Callable[..., bool],*, name: Optional[str] = None, quant: Quantifier = Quantifier.FORALL)->Callable[..., Constraint]:
+        def wrapper(*args: Any, **kwargs:Any) -> Constraint:
+            arg_list = list(args)
+            kw_list = [(k, v) for k, v in kwargs.items()]
+            def run_f(bound: BoundVar) -> bool:
+                # positional argument values
+                pos_values = [
+                    arg.get(bound) if isinstance(arg, Variable) else (arg,)
+                    for arg in arg_list
+                ]
+                # keyword argument values
+                kw_keys, kw_values = zip(*[
+                    (k, v.get(bound) if isinstance(v, Variable) else (v,))
+                    for k, v in kw_list
+                ]) if kw_list else ([], [])
+
+                # Cartesian product over all argument values
+                all_combos = product(*pos_values, *kw_values)
+
+                # evaluate predicate on each combination
+                def eval_combo(combo):
+                    pos_args = combo[:len(pos_values)]
+                    kw_args = dict(zip(kw_keys, combo[len(pos_values):]))
+                    return f(*pos_args, **kw_args)
+
+                if quant is Quantifier.EXISTS:
+                    return any(eval_combo(c) for c in all_combos)
+                else:
+                    return all(eval_combo(c) for c in all_combos)
+            return cls(run_f=run_f, name = name or f.__name__)
+        return wrapper
+
+    @classmethod
+    def forall(cls, f: Callable[..., bool], name: Optional[str] = None) -> Callable[..., Constraint]:
+        return cls.predicate(f, name=name, quant=Quantifier.FORALL)
+    
+    @classmethod
+    def exists(cls, f: Callable[..., bool], name: Optional[str] = None):
+        return cls.predicate(f, name=name, quant=Quantifier.EXISTS)
+
+

syncraft/diagnostic.py

@@ -10,7 +10,7 @@ from sqlglot.expressions import Expression
 
 
 def rich_error(err: Error)->None:
-    lst = err.to_list(lambda _: True)
+    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")
@@ -26,9 +26,9 @@ def rich_error(err: Error)->None:
     print(tbl)
 
 
-def rich_parser(p: Any)-> None:
+def rich_parser(p: Syntax)-> None:
     print("Parser Debug Information:")
-    print(p._string or repr(p))
+    print(p.meta.to_string(lambda _ : True) or repr(p))
 
 def rich_debug(this: Algebra[Any, ParserState[Any]], 
                state: ParserState[Any], 
@@ -44,8 +44,8 @@ def rich_debug(this: Algebra[Any, ParserState[Any]],
                 return prefix + value.sql()
             elif isinstance(value, Token):
                 return prefix + f"{value.token_type.name}({value.text})"
-            elif isinstance(value, (Error, ParserState, Syntax)):
-                return prefix + (value._string or 'N/A')
+            elif isinstance(value, Syntax):
+                return prefix + (value.meta.to_string(lambda _ : True) or 'N/A')
             else:
                 return prefix + str(value)
 

syncraft/finder.py

@@ -1,96 +1,34 @@
 from __future__ import annotations
 
 from typing import (
-    Any, Tuple, Optional,  Callable,
-    List, Generator as YieldGen
+    Any, Tuple, Optional, Generator as YieldGen
 )
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from syncraft.algebra import (
-    Algebra, Either, Left, Right, Error, 
-    OrResult, ManyResult, ThenResult, NamedResult
+    Algebra, Either, Right, 
+    OrResult, ManyResult, ThenResult, MarkedResult
 )
 
-from syncraft.ast import T, ParseResult, Token, AST
-from syncraft.generator import GenState, TokenGen, B
+from syncraft.ast import T, ParseResult, AST
+from syncraft.generator import GenState, Generator
 from sqlglot import TokenType
 from syncraft.syntax import Syntax
 import re
 
-@dataclass(frozen=True)
-class Finder(Algebra[ParseResult[T], GenState[T]]):  
-    def flat_map(self, f: Callable[[ParseResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
-        def flat_map_run(original: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
-            wrapper = original.wrapper()
-            input = original if not original.is_named else original.down(0)  # If the input is named, we need to go down to the first child
-            try:
-                lft = input.left() 
-                match self.run(lft, use_cache=use_cache):
-                    case Left(error):
-                        return Left(error)
-                    case Right((value, next_input)):
-                        r = input.right() 
-                        match f(value).run(r, use_cache):
-                            case Left(e):
-                                return Left(e)
-                            case Right((result, next_input)):
-                                return Right((wrapper(result), next_input))
-                raise ValueError("flat_map should always return a value or an error.")
-            except Exception as e:
-                return Left(Error(
-                    message=str(e),
-                    this=self,
-                    state=original,
-                    error=e
-                ))
-        return Finder(run_f = flat_map_run, name=self.name) # type: ignore
-
 
+@dataclass(frozen=True)
+class Finder(Generator[T]):      
     def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[ParseResult[T]], GenState[T]]:
         assert at_least > 0, "at_least must be greater than 0"
         assert at_most is None or at_least <= at_most, "at_least must be less than or equal to at_most"
-        def many_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ManyResult[ParseResult[T]], GenState[T]]]:
-            wrapper = input.wrapper()
-            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
-            ret = []
-            for index in range(input.how_many): 
-                match self.run(input.down(index), use_cache):
-                    case Right((value, next_input)):
-                        ret.append(value)
-                        if at_most is not None and len(ret) > at_most:
-                            return Left(Error(
-                                    message=f"Expected at most {at_most} matches, got {len(ret)}",
-                                    this=self,
-                                    state=input.down(index)
-                                ))                             
-                    case Left(_):
-                        pass
-            if len(ret) < at_least:
-                return Left(Error(
-                    message=f"Expected at least {at_least} matches, got {len(ret)}",
-                    this=self,
-                    state=input.down(index)
-                )) 
-            return Right((wrapper(ManyResult(tuple(ret))), input))
-        return self.__class__(many_run, name=f"many({self.name})")  # type: ignore
+        return self.map_state(lambda s: replace(s, is_pruned = False)).many(at_least=at_least, at_most=at_most)
     
  
     def or_else(self, # type: ignore
                 other: Algebra[ParseResult[T], GenState[T]]
                 ) -> Algebra[OrResult[ParseResult[T]], GenState[T]]: 
-        def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[OrResult[ParseResult[T]], GenState[T]]]:
-            wrapper = input.wrapper()
-            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
-            match self.run(input.down(0), use_cache):
-                case Right((value, next_input)):
-                    return Right((wrapper(OrResult(value)), next_input))
-                case Left(error):
-                    match other.run(input.down(0), use_cache):
-                        case Right((value, next_input)):
-                            return Right((wrapper(OrResult(value)), next_input))
-                        case Left(error):
-                            return Left(error)
-            raise ValueError("or_else should always return a value or an error.")
-        return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})") # type: ignore
+        return self.map_state(lambda s: replace(s, is_pruned = False)).or_else(other) 
+        
 
     @classmethod
     def token(cls, 
@@ -98,20 +36,12 @@ class Finder(Algebra[ParseResult[T], GenState[T]]):
               text: Optional[str] = None, 
               case_sensitive: bool = False,
               regex: Optional[re.Pattern[str]] = None
-              )-> Algebra[ParseResult[T], GenState[T]]:      
-        gen = TokenGen(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)  
-        lazy_self: Algebra[ParseResult[T], GenState[T]]
-        def token_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ParseResult[Token], GenState[T]]]:
-            wrapper = input.wrapper()
-            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
-            current = input.focus
-            if not isinstance(current, Token) or not gen.is_valid(current):
-                return Left(Error(None, 
-                                    message=f"Expected a Token, but got {type(current)}.", 
-                                    state=input))
-            return Right((wrapper(current), input))
-        lazy_self = cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})')  # type: ignore
-        return lazy_self
+              )-> Algebra[ParseResult[T], GenState[T]]: 
+        return super().token(token_type=token_type, 
+                               text=text, 
+                               case_sensitive=case_sensitive, 
+                               regex=regex).map_state(lambda s: replace(s, is_pruned = False)) # type: ignore
+
 
     @classmethod
     def anything(cls)->Algebra[ParseResult[T], GenState[T]]:
@@ -141,7 +71,7 @@ def find(syntax: Syntax[Any, Any], data: AST[Any]) -> YieldGen[AST[Any], None, N
         case ManyResult(value = value):
             for e in value:
                 yield from find(syntax, AST(e))
-        case NamedResult(value=value):
+        case MarkedResult(value=value):
             yield from find(syntax, AST(value))
         case OrResult(value=value):
             yield from find(syntax, AST(value))

syncraft/generator.py

@@ -11,7 +11,8 @@ from syncraft.algebra import (
     OrResult, ManyResult
 )
 
-from syncraft.ast import T, ParseResult, AST, Token, TokenSpec
+from syncraft.ast import T, ParseResult, AST, Token, TokenSpec, Binding, Variable, Bindable
+
 from syncraft.syntax import Syntax
 from sqlglot import TokenType
 import re
@@ -23,9 +24,13 @@ B = TypeVar('B')
 
 
 @dataclass(frozen=True)
-class GenState(Generic[T]):
+class GenState(Bindable, Generic[T]):
     ast: Optional[AST[T]]
     seed: int
+    is_pruned: Optional[bool] = None
+    binding: Binding = Binding()
+    def bind(self, var: Variable, node:ParseResult[T])->GenState[T]:
+        return replace(self, binding=self.binding.bind(var, node))
 
     def fork(self, tag: Any) -> GenState[T]:
         return replace(self, seed=hash((self.seed, tag)))
@@ -38,7 +43,10 @@ class GenState(Generic[T]):
 
     @cached_property
     def pruned(self)->bool:
-        return self.ast is None or self.ast.pruned
+        if self.is_pruned is None:
+            return self.ast is None or self.ast.pruned
+        else:
+            return self.is_pruned
     
 
     @property
@@ -167,7 +175,7 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                     state=original,
                     error=e
                 ))
-        return Generator(run_f = flat_map_run, name=self.name) # type: ignore
+        return self.__class__(run_f = flat_map_run, name=self.name) # type: ignore
 
 
     def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[ParseResult[T]], GenState[T]]:

syncraft/parser.py

@@ -3,7 +3,7 @@ import re
 from sqlglot import tokenize, TokenType, Parser as GlotParser, exp
 from typing import (
     Optional, List, Any, Tuple,
-    Generic, Callable
+    Generic, Callable, Hashable
 )
 from syncraft.algebra import (
     Either, Left, Right, Error, Algebra
@@ -13,13 +13,16 @@ from enum import Enum
 from functools import reduce
 from syncraft.syntax import Syntax
 
-from syncraft.ast import Token, TokenSpec, AST, T
+from syncraft.ast import Token, TokenSpec, AST, T, ParseResult, Binding, Variable, Bindable
 
 
 @dataclass(frozen=True)
-class ParserState(Generic[T]):
+class ParserState(Bindable, Generic[T]):
     input: Tuple[T, ...] = field(default_factory=tuple)
     index: int = 0
+    binding: Binding[ParseResult[T]] = Binding()
+    def bind(self, var: Variable, node:ParseResult[T])->ParserState[T]:
+        return replace(self, binding=self.binding.bind(var, node))
     
     def token_sample_string(self)-> str:
         def encode_tokens(*tokens:T) -> str:

syncraft/syntax.py

@@ -6,7 +6,9 @@ from typing import (
 )
 from dataclasses import dataclass, field, replace
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, ThenResult, ManyResult, ThenKind, NamedResult
+from syncraft.algebra import Algebra, Error, Either, Right
+from syncraft.constraint import Variable, Bindable
+from syncraft.ast import ThenResult, ManyResult, ThenKind, MarkedResult
 from types import MethodType, FunctionType
 
 
@@ -15,33 +17,9 @@ from types import MethodType, FunctionType
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Result type for mapping
 C = TypeVar('C')  # Result type for else branch
-S = TypeVar('S')  # State type
-
-
-class Variable(Generic[A]):
-    def __init__(self, name: Optional[str] = None):
-        self.name = name
-        self.initialized = False
-        self._value = None
-    def __call__(self, a: Any) -> Any:
-        if self.initialized:
-            if self._value != a:
-                raise ValueError(f"Variable {self.name or ''} is already initialized")
-            else:
-                return a
-        elif self.name is not None and isinstance(a, NamedResult):
-            if a.name == self.name:
-                self._value = a.value
-                self.initialized = True
-        else:
-            self._value = a
-            self.initialized = True
-        return a
-    @property
-    def value(self) -> A:
-        if self.initialized is False or self._value is None:
-            raise ValueError(f"Variable {self.name or ''} is not initialized")
-        return self._value
+S = TypeVar('S', bound=Bindable)  # State type
+
+
 
 
 @dataclass(frozen=True)
@@ -157,11 +135,15 @@ class Syntax(Generic[A, S]):
     def map(self, f: Callable[[A], B]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).map(f), meta = self.meta) # type: ignore
 
+    def map_all(self, f: Callable[[Either[Any, Tuple[A, S]]], Either[Any, Tuple[B, S]]]) -> Syntax[B, S]:
+        return self.__class__(lambda cls: self.alg(cls).map_all(f), meta=self.meta) # type: ignore
+
     def map_error(self, f: Callable[[Optional[Any]], Any]) -> Syntax[A, S]:
         return self.__class__(lambda cls: self.alg(cls).map_error(f), meta=self.meta)
     
     def map_state(self, f: Callable[[S], S]) -> Syntax[A, S]:
         return self.__class__(lambda cls: self.alg(cls).map_state(f), meta=self.meta)
+    
 
     def flat_map(self, f: Callable[[A], Algebra[B, S]]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).flat_map(f)) # type: ignore
@@ -251,16 +233,23 @@ class Syntax(Generic[A, S]):
 
 
 ######################################################################## data processing combinators #########################################################
-    def bind(self, name: str) -> Syntax[NamedResult[A], S]:
-        def bind_f(value: A) -> NamedResult[A]:
-            if isinstance(value, NamedResult):
-                return replace(value, name=name)    
+    def bind(self, var: Variable) -> Syntax[A, S]:
+        def bind_v(result: Either[Any, Tuple[A, S]])->Either[Any, Tuple[A, S]]:
+            if isinstance(result, Right):
+                value, state = result.value
+                return Right((value, state.bind(var, value)))
+            return result
+        return self.map_all(bind_v).describe(name=f'bind({var.name})', fixity='postfix', parameter=[self])  
+
+    def mark(self, var: str) -> Syntax[MarkedResult[A], S]:
+        def bind_s(value: A) -> MarkedResult[A]:
+            if isinstance(value, MarkedResult):
+                return replace(value, name=var)    
             else:
-                return NamedResult(name=name, value=value)
-        return self.map(bind_f).describe(name=f'bind("{name}")', fixity='postfix', parameter=[self]) 
+                return MarkedResult(name=var, value=value)
+        return self.map(bind_s).describe(name=f'bind("{var}")', fixity='postfix', parameter=[self]) 
+
 
-    def assign(self, var: Variable[A]) -> Syntax[A, S]:
-        return self.map(var).describe(name=f'assign({var.name or ""})', fixity='postfix', parameter=[self])
 
     def dump_error(self, formatter: Optional[Callable[[Error], None]] = None) -> Syntax[A, S]:
         def dump_error_run(err: Any)->Any:
@@ -299,13 +288,18 @@ def first(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
 def last(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
     return reduce(lambda a, b: a >> b, parsers) if len(parsers) > 0 else success(None)
 
-def named(* parsers: Syntax[Any, S] | Tuple[str, Syntax[Any, S]]) -> Syntax[Any, S]:
+def bound(* parsers: Syntax[Any, S] | Tuple[str|Variable, 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)
+        return isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], (str, Variable)) 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):
-            return x[1].bind(x[0])
+    def to_parser(x: Syntax[Any, S] | Tuple[str|Variable, Syntax[Any, S]])->Syntax[Any, S]:
+        if isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], (str, Variable)) and isinstance(x[1], Syntax):
+            if isinstance(x[0], str):
+                return x[1].mark(x[0])
+            elif isinstance(x[0], Variable):
+                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:

{syncraft-0.1.21.dist-info → syncraft-0.1.24.dist-info}/METADATA

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

syncraft-0.1.24.dist-info/RECORD

@@ -0,0 +1,16 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=Um8iMgVwlWcseQDkB_GqY-xmo0hR7zSw5j7oRRxrZhE,14122
+syncraft/ast.py,sha256=TM18FkdFIBbxaaKgEvTvellrcXdkzMLLjLm7sRuC7FY,12985
+syncraft/constraint.py,sha256=4io1HM_2y5SJzMoeVowAr0a-SDE2jR-7uhCcZpa_FlM,6219
+syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
+syncraft/finder.py,sha256=QySZcIjWZFMbRxGJVlJDxK9cmIuNA5vnoE-vYwLJiqA,3005
+syncraft/generator.py,sha256=6jfkSODx952OiN-oOJdNubvU2TzYhLzh3wibZV-ImbI,11625
+syncraft/parser.py,sha256=nSQInixB4j7H22HV_9YdOXfRB5aCPnhQYvMC_N5jnlo,11538
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=wwMPAfae5mH4ip3Q2JOkvFkccPfoVDkb-Tk5o0U-ecI,14843
+syncraft-0.1.24.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.24.dist-info/METADATA,sha256=jleKB866QNoRRkpcmtNflWRHUS4HgNYqQsg9zfJHd4Q,1381
+syncraft-0.1.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.24.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.24.dist-info/RECORD,,

syncraft/cmd.py

@@ -1,61 +0,0 @@
-import subprocess
-import tempfile
-from typing import List, Tuple
-from dataclasses import dataclass, field
-
-@dataclass(frozen=True)
-class Sqlite3Result:
-    stdout: Tuple[str, ...] = field(default_factory=tuple)
-    stderr: Tuple[str, ...] = field(default_factory=tuple)
-    schema: Tuple[str, ...] = field(default_factory=tuple)
-
-
-class SQLite3:
-    def __init__(self, cmd: str = 'sqlite3'):
-        self.cmd = cmd
-
-    
-    def exec(self, sql: str)->Sqlite3Result:
-        with tempfile.NamedTemporaryFile(suffix=".db") as temp_db:
-            process = subprocess.run(
-                [self.cmd, temp_db.name],
-                input=sql.encode(),
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-            stdout = process.stdout.decode('utf-8').strip().splitlines()
-            stderr = process.stderr.decode('utf-8').strip().splitlines()
-            schema_process = subprocess.run(
-                [self.cmd, temp_db.name, '.schema'],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-            schema = schema_process.stdout.decode('utf-8').strip().splitlines()
-            return Sqlite3Result(
-                stdout=tuple(stdout),
-                stderr=tuple(stderr),
-                schema=tuple(schema)
-            )
-    
-
-if __name__ == "__main__":
-    sql = """
-    DROP TABLE IF EXISTS test;
-    DROP TABLE IF EXISTS error;
-    DROP INDEX IF EXISTS idx_name;
-    CREATE TABLE d.x (id INTEGER PRIMARY KEY, name TEXT);
-
-    CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT);
-    CREATE TABLE IF NOT EXISTS error (id INTEGER PRIMARY KEY, name TEXT); 
-    CREATE INDEX IF NOT EXISTS idx_name ON test(name);
-    CREATE TRIGGER IF NOT EXISTS trg_test 
-    AFTER INSERT ON test 
-    BEGIN 
-        INSERT INTO error (name) VALUES ('Trigger Error'); 
-    END;
-    """
-    result = SQLite3().exec(sql)
-    print("STDOUT:", result.stdout)
-    print("STDERR:", result.stderr)
-    print("SCHEMA:", result.schema)
-

syncraft-0.1.21.dist-info/RECORD

@@ -1,16 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=bya-2b5WpCcOMxgJjGqrFaNG8dCjs5NUqnxbJTc4uOM,21908
-syncraft/ast.py,sha256=Hn88_xOqSzrHYtPjNFKREJuE6yISmNI-VVTcU6PJKI0,4737
-syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
-syncraft/diagnostic.py,sha256=mnzzceE9HpN2jVa7ztecZCz3sbCD79JxgkdLhJRBsvY,2822
-syncraft/finder.py,sha256=zADOQQdcHu60413ZrRxTSq-E5EAJ9xv0OQodCpoYpo0,7202
-syncraft/generator.py,sha256=Mh9Sx1hNR0EAWcox6MMvVw7aq2s33TU4stGZFZ1N1cw,11287
-syncraft/parser.py,sha256=PSy9s3q_KXQh-Qlg0NxvJixxcgVYi3yCq0ebqlA5WwM,11288
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=yUp3DmDnkwNEqDAFZH4vesjdnbIUsrwFjWN-Ljy1qN4,14880
-syncraft-0.1.21.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.21.dist-info/METADATA,sha256=cJyW-BifZOf3RdmFKp1-auJv13aMNjRwk1VDqPG5gR4,1381
-syncraft-0.1.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.21.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.21.dist-info/RECORD,,