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

syncraft/algebra.py

@@ -77,7 +77,7 @@ class Algebra(Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################
     run_f: Callable[[S, bool], Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]] 
     name: Hashable
-    cache: Cache[ S, Either[Any, Tuple[A, S]] ]
+    cache: Cache[Either[Any, Tuple[A, S]]]
 
     @classmethod
     def state(cls, **kwargs:Any)->Optional[S]: 
@@ -103,10 +103,10 @@ class Algebra(Generic[A, S]):
              cache: Cache) -> Algebra[A, S]:
         def algebra_lazy_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
             alg = thunk()
-            print('--' * 20, "Algebra.lazy.algebra_lazy_run", '--' * 20)
-            print('thunk', thunk, id(thunk))
-            print('input', input, id(input))
-            print('alg', alg, id(alg))
+            # print('--' * 20, "Algebra.lazy.algebra_lazy_run", '--' * 20)
+            # print('thunk', thunk, id(thunk))
+            # print('input', input, id(input))
+            # print('alg', alg, id(alg))
             result = yield from alg.run(input, use_cache)
             return result
         return cls(algebra_lazy_run, name=cls.__name__ + '.lazy', cache=cache)

syncraft/ast.py

@@ -491,6 +491,7 @@ class LazySpec(SyntaxSpec, Generic[A]):
     value: A
 @dataclass(frozen=True)
 class ThenSpec(SyntaxSpec, Generic[A, B]):
+    kind: ThenKind
     left: A
     right: B
 

syncraft/cache.py

@@ -30,8 +30,8 @@ Args = TypeVar('Args', bound=Hashable)
 Ret = TypeVar('Ret')
 
 @dataclass
-class Cache(Generic[Args, Ret]):
-    cache: WeakKeyDictionary[Callable[..., Any], Dict[Args, Ret | InProgress]] = field(default_factory=WeakKeyDictionary)
+class Cache(Generic[Ret]):
+    cache: WeakKeyDictionary[Callable[..., Any], Dict[Hashable, Ret | InProgress]] = field(default_factory=WeakKeyDictionary)
 
     def __contains__(self, f: Callable[..., Any]) -> bool:
         return f in self.cache
@@ -40,74 +40,103 @@ class Cache(Generic[Args, Ret]):
         return f"Cache({({f.__name__: list(c.keys()) for f, c in self.cache.items()})})"
 
 
-    def __or__(self, other: Cache[Args, Any]) -> Cache[Args, Any]:
+    def __or__(self, other: Cache[Any]) -> Cache[Any]:
         assert self.cache is other.cache, "There should be only one global cache"
-        if self.cache is other.cache:
-            return self
-        elif len(self.cache) == 0:
-            return other
-        elif len(other.cache) == 0:
-            return self
-        merged = Cache[Args, Ret]()
-        for f, c in self.cache.items():
-            merged.cache[f] = c.copy()
-        for f, c in other.cache.items():
-            merged.cache.setdefault(f, {}).update(c)
-        return merged
+        return self
 
     @overload
     def _execute(self, 
-                 f: Callable[[Args, bool], Ret], 
-                 args: Args, 
-                 use_cache: bool, 
-                 is_gen: Literal[False]) -> Ret: ...
+                 f: Callable[..., Ret], 
+                 *args:Any, 
+                 is_gen: Literal[False], 
+                 **kwargs:Any) -> Ret: ...
     @overload
     def _execute(self, 
-                 f: Callable[[Args, bool], Generator[Any, Any, Ret]], 
-                 args: Args, 
-                 use_cache: bool, 
-                 is_gen: Literal[True]) -> Generator[Any, Any, Ret]: ...
+                 f: Callable[..., Generator[Any, Any, Ret]], 
+                 *args: Any, 
+                 is_gen: Literal[True], 
+                 **kwargs: Any) -> Generator[Any, Any, Ret]: ...
 
 
     def _execute(self, 
-            f: Callable[[Args, bool], Any], 
-            args: Args, 
-            use_cache:bool,
-            is_gen: bool
-            ) -> Ret | Generator[Any, Any, Ret]:
+            f: Callable[..., Any], 
+            *args: Any,
+            is_gen: bool,
+            **kwargs: Any) -> Ret | Generator[Any, Any, Ret]:
         if f not in self.cache:
             self.cache.setdefault(f, dict())
-        c: Dict[Args, Ret | InProgress] = self.cache[f]
-        if args in c:
-            v = c[args]
+        c: Dict[Hashable, Ret | InProgress] = self.cache[f]
+        key = (args, tuple(sorted(kwargs.items())))
+        if key in c:
+            v = c[key]
             if isinstance(v, InProgress):
                 raise RecursionError("Left-recursion detected in parser", offending=f, state=args)
             else:
                 return v        
         try:
-            c[args] = InProgress()
+            c[key] = InProgress()
             if is_gen:
-                result = yield from f(args, use_cache)
+                result = yield from f(*args, **kwargs)
             else:
-                result = f(args, use_cache)
-            c[args] = result
-            if not use_cache:
-                c.pop(args, None)
+                result = f(*args, **kwargs)
+            c[key] = result
+            if kwargs.get('use_cache', True) is False:
+                c.pop(key, None)
             return result
         except Exception as e:
-            c.pop(args, None)  
+            c.pop(key, None)
             raise e
         
     def gen(self, 
-            f: Callable[[Args, bool], Generator[Any, Any, Ret]], 
-            args: Args, 
-            use_cache:bool) -> Generator[Any, Any, Ret]:
-        return (yield from self._execute(f, args, use_cache, is_gen=True)) 
+            f: Callable[..., Generator[Any, Any, Ret]], 
+            *args: Any, 
+            **kwargs: Any) -> Generator[Any, Any, Ret]:
+        if f not in self.cache:
+            self.cache.setdefault(f, dict())
+        c: Dict[Hashable, Ret | InProgress] = self.cache[f]
+        key = (tuple(filter(lambda x: not isinstance(x, Cache), args)), tuple(sorted(filter(lambda item: not isinstance(item[1], Cache), kwargs.items()))))        
+        if key in c:
+            v = c[key]
+            if isinstance(v, InProgress):
+                raise RecursionError("Left-recursion detected in parser", offending=f, state=args)
+            else:
+                return v        
+        try:
+            c[key] = InProgress()
+            result = yield from f(*args, **kwargs)
+            c[key] = result
+            if kwargs.get('use_cache', True) is False:
+                c.pop(key, None)
+            return result
+        except Exception as e:
+            c.pop(key, None)
+            raise e
+        
 
     def call(self, 
-            f: Callable[[Args, bool], Ret], 
-            args: Args, 
-            use_cache:bool) -> Ret:
-        return self._execute(f, args, use_cache, is_gen=False) 
+             f: Callable[..., Ret], 
+             *args:Any, 
+             **kwargs:Any) -> Ret:
+        if f not in self.cache:
+            self.cache.setdefault(f, dict())
+        c: Dict[Hashable, Ret | InProgress] = self.cache[f]
+        key = (tuple(filter(lambda x: not isinstance(x, Cache), args)), tuple(sorted(filter(lambda item: not isinstance(item[1], Cache), kwargs.items()))))
+        if key in c:
+            v = c[key]
+            if isinstance(v, InProgress):
+                raise RecursionError("Left-recursion detected in parser", offending=f, state=args)
+            else:
+                return v        
+        try:
+            c[key] = InProgress()
+            result = f(*args, **kwargs)
+            c[key] = result
+            if kwargs.get('use_cache', True) is False:
+                c.pop(key, None)
+            return result
+        except Exception as e:
+            c.pop(key, None)
+            raise e
+        
 
 

syncraft/generator.py

@@ -245,7 +245,7 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
             Algebra[B, GenState[T]]: An algebra yielding the final result.
         """
         def flat_map_run(input: GenState[T], use_cache:bool) -> PyGenerator[Incomplete[GenState[T]], GenState[T], Either[Any, Tuple[B, GenState[T]]]]:
-            if not isinstance(input.ast, Then) or isinstance(input.ast, Nothing):
+            if not input.pruned and (not isinstance(input.ast, Then) or isinstance(input.ast, Nothing)):
                 return Left(Error(this=self, 
                                     message=f"Expect Then got {input.ast}",
                                     state=input))

syncraft/parser.py

@@ -122,18 +122,6 @@ class ParserState(Bindable, Generic[T]):
 class Parser(Algebra[T, ParserState[T]]):
     @classmethod
     def state(cls, sql: str, dialect: str) -> ParserState[T]: # type: ignore
-        """Tokenize SQL text into an initial ``ParserState``.
-
-        Uses ``sqlglot.tokenize`` for the given dialect and wraps tokens into
-        the project's ``Token`` type.
-
-        Args:
-            sql: The SQL text to tokenize.
-            dialect: The sqlglot dialect name (e.g. "sqlite", "duckdb").
-
-        Returns:
-            ParserState[T]: Initial parser state at index 0.
-        """
         tokens = tuple([Token(token_type=token.token_type, text=token.text) for token in tokenize(sql, dialect=dialect)])
         return ParserState.from_tokens(tokens)  # type: ignore
 
@@ -146,21 +134,6 @@ class Parser(Algebra[T, ParserState[T]]):
               case_sensitive: bool = False,
               regex: Optional[re.Pattern[str]] = None
               )-> Algebra[T, ParserState[T]]:
-        """Match a single token according to a specification.
-
-        Succeeds when the current token satisfies the provided
-        ``TokenSpec`` (by type, exact text, or regex). On failure,
-        an informative ``Error`` is produced with location context.
-
-        Args:
-            token_type: Expected enum type of the token.
-            text: Exact token text to match.
-            case_sensitive: Whether text matching is case sensitive.
-            regex: Regular expression pattern to match token text.
-
-        Returns:
-            Algebra[T, ParserState[T]]: An algebra yielding the matched token.
-        """
         spec = TokenSpec(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)
         def token_run(state: ParserState[T], use_cache:bool) -> Generator[Incomplete[ParserState[T]],ParserState[T], Either[Any, Tuple[T, ParserState[T]]]]:
             while True:

syncraft/syntax.py

@@ -54,7 +54,7 @@ class Syntax(Generic[A, S]):
     """
     The core signature of Syntax is take an Algebra Class and return an Algebra Instance.
     """
-    alg: Callable[[Type[Algebra[Any, Any]], Cache[Any, Any]], Algebra[A, S]]
+    alg: Callable[[Type[Algebra[Any, Any]], Cache[Any]], Algebra[A, S]]
     meta: Description = field(default_factory=Description, repr=False)
 
     def algebra(self, name: str | MethodType | FunctionType, *args: Any, **kwargs: Any) -> Syntax[A, S]:
@@ -71,7 +71,7 @@ class Syntax(Generic[A, S]):
         Returns:
             A new Syntax reflecting the transformed algebra.
         """
-        def algebra_run(cls: Type[Algebra[Any, S]], cache: Cache[Any, Any]) -> Algebra[Any, S]:
+        def algebra_run(cls: Type[Algebra[Any, S]], cache: Cache[Any]) -> Algebra[Any, S]:
             a = self(cls, cache)
             if isinstance(name, str):
                 attr = getattr(a, name, None) or getattr(cls, name, None)
@@ -97,7 +97,7 @@ class Syntax(Generic[A, S]):
     def as_(self, typ: Type[B]) -> B:
         return cast(typ, self)  # type: ignore
 
-    def __call__(self, alg: Type[Algebra[Any, Any]], cache: Cache[Any, Any]) -> Algebra[A, S]:
+    def __call__(self, alg: Type[Algebra[Any, Any]], cache: Cache[Any]) -> Algebra[A, S]:
         return self.alg(alg, cache)
 
 
@@ -562,37 +562,28 @@ def run(*,
 
 
 def lazy(thunk: Callable[[], Syntax[A, S]]) -> Syntax[A, S]:
-    syntax: Optional[Syntax[A, S]] = None
     algebra: Optional[Algebra[A, S]] = None
+    syntax: Optional[Syntax[A, S]] = None
+    previous_cls: Optional[Type[Algebra[Any, S]]] = None
     def syntax_lazy_run(cls: Type[Algebra[Any, S]], cache: Cache) -> Algebra[A, S]:
-        nonlocal syntax, algebra
-        print('==' * 20, 'Syntax.lazy.syntax_lazy_run', '==' * 20)
-        print('thunk', thunk, id(thunk))
-        print('syntax', syntax, id(syntax))
-        print('algebra', algebra, id(algebra))
+        nonlocal algebra, syntax, previous_cls
+        # print('==' * 20, 'Syntax.lazy.syntax_lazy_run', '==' * 20)
+        # print('thunk', thunk, id(thunk))
+        # print('syntax', syntax, id(syntax))
+        # print('algebra', algebra, id(algebra))
         if syntax is None:
             syntax = thunk()
         def algebra_lazy_f():
             if syntax is None:
                 raise SyncraftError("Lazy thunk did not resolve to a Syntax", offending=thunk, expect="a Syntax")
             return syntax(cls, cache)
-        if algebra is None:
-            algebra = cls.lazy(algebra_lazy_f, cache=cache)  
+        if algebra is None or (previous_cls is not None and previous_cls is not cls):
+            algebra = cls.lazy(algebra_lazy_f, cache=cache)
+            previous_cls = cls
         return algebra
     return Syntax(syntax_lazy_run).describe(name='lazy(?)', fixity='postfix') 
 
 
-# def lazy(thunk: Callable[[], Syntax[A, S]]) -> Syntax[A, S]:
-#     resolved: Optional[Syntax[A, S]] = None
-    
-#     def run_lazy(cls: Type[Algebra[Any, S]], cache: Cache) -> Algebra[A, S]:
-#         nonlocal resolved
-#         if resolved is None:
-#             resolved = thunk()
-#         return resolved(cls, cache)  # reuse the same Algebra instance
-#     return Syntax(run_lazy)
-
-
 
 
 def token(*,

syncraft/walker.py

@@ -7,13 +7,14 @@ 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.ast import TokenSpec, ThenSpec, ManySpec, ChoiceSpec, LazySpec, ThenKind
 from syncraft.parser import TokenType
 from syncraft.constraint import Bindable, FrozenDict
 
 import re
 from syncraft.syntax import Syntax
 from syncraft.cache import Cache
+from rich import print
 
 
 S = TypeVar('S', bound=Bindable)
@@ -31,7 +32,6 @@ SS = TypeVar('SS', bound=Hashable)
 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]:
@@ -41,8 +41,6 @@ class WalkerState(Bindable, Generic[SS]):
         else:
             return replace(self, acc=value)
         
-    def visit(self, key: Hashable) -> WalkerState[SS]:
-        return replace(self, visited=self.visited | {key})
 
 
 
@@ -55,24 +53,40 @@ class Walker(Algebra[SS, WalkerState[SS]]):
         return WalkerState(reducer=reducer, acc=init)
 
 
+
+    @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)  
+
     @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)))
+    def lazy(cls, 
+             thunk: Callable[[], Algebra[Any, WalkerState[SS]]], 
+             cache: Cache) -> Algebra[Any, WalkerState[SS]]:
+        def algebra_lazy_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+            alg = thunk()
+            print('--' * 20, "Walker.lazy.algebra_lazy_run", '--' * 20)
+            print('thunk', thunk, id(thunk))
+            print('input', input, id(input))
+            print('alg', alg, id(alg))
+            thunk_result = yield from alg.run(input, use_cache)
+            match thunk_result:
+                case Right((value, from_thunk)):
+                    data = LazySpec(value=value)
+                    return Right((data, from_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)
+        return cls(algebra_lazy_run, name=cls.__name__ + '.lazy', cache=cache)
+
 
 
     def then_both(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
@@ -83,16 +97,16 @@ class Walker(Algebra[SS, WalkerState[SS]]):
                     other_result = yield from other.run(from_left, use_cache)
                     match other_result:
                         case Right((result, from_right)):
-                            data = ThenSpec(left=value, right=result)
+                            data = ThenSpec(kind=ThenKind.BOTH, 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
+        return self.then_both(other).map(lambda t: replace(t, kind=ThenKind.LEFT))
 
     def then_right(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
-        return self.then_both(other)
+        return self.then_both(other).map(lambda t: replace(t, kind=ThenKind.RIGHT))
 
 
     def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Any, WalkerState[SS]]:
@@ -121,27 +135,9 @@ class Walker(Algebra[SS, WalkerState[SS]]):
             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]:
+def walk(syntax: Syntax[Any, Any], reducer: Callable[[Any, Any], SS], init: SS)-> Tuple[Any, None | 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
+    return v, s

{syncraft-0.2.6.dist-info → syncraft-0.2.8.dist-info}/METADATA

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

syncraft-0.2.8.dist-info/RECORD

@@ -0,0 +1,20 @@
+syncraft/__init__.py,sha256=g1Rd3DwPJ-Z7dL0PBNyNkcLBmpkp8bIBDWabkeBCD48,1329
+syncraft/algebra.py,sha256=RfI6IzVPflDMuONbajGmqDYo0gR2Yqt3GSaZ8M0N-cs,20709
+syncraft/ast.py,sha256=UZSByp1XZjaBMldc6AVL6bZcjTbPPi7qtlAM1HwY2Tk,20798
+syncraft/cache.py,sha256=oqF0E-jHFzYW36YqPRQm-wP_8_YhcB6VfGNdvgllE0w,4827
+syncraft/constraint.py,sha256=a6j_VafRor8W7FBXh20DoVnIUO9nfn7eIValigCf9lU,16318
+syncraft/dev.py,sha256=v7jdb2aOVCGbio-Jw14tRhO09FkhWc0vrDdIkIKPu2Y,186
+syncraft/finder.py,sha256=Mv9BYrsDjjq62Z4NO3gElZAbkEgSBINhSbqFbKEQW4Q,4347
+syncraft/generator.py,sha256=2q_dRKZlPLdfyrwdZqL01KpNes00qLKm-D13OWzN79I,21232
+syncraft/lexer.py,sha256=npPHAEEbBRQYcFHPMHtXmiVLbCZAnjpTtj3cnVui4W0,3720
+syncraft/parser.py,sha256=bdCbbeJ5p-j8kJniqmKSRAE8N3pCWN-ltJIpALW0h54,9070
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=ILIEK0GQp0_rpXJYEAX9E_wN7ouTUiFfyGqlQtaAJN4,24794
+syncraft/utils.py,sha256=2V446Il2q4mR7bwwGX5_qruJPU0WXU2PniXEjl6EOPE,8746
+syncraft/walker.py,sha256=-IFS8M_cL5qG2meJleo_AS2ejTis0bnLWu-6Yw-ILUk,6817
+syncraft-0.2.8.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.2.8.dist-info/METADATA,sha256=2QiTtmFXvxrquEPGn1eqBTSbsesiHavUf_KyQgxQtHk,1023
+syncraft-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.2.8.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.2.8.dist-info/RECORD,,

syncraft-0.2.6.dist-info/RECORD

@@ -1,20 +0,0 @@
-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,,