syncraft 0.1.38__py3-none-any.whl → 0.2.1__py3-none-any.whl

syncraft/algebra.py

@@ -7,7 +7,6 @@ from typing import (
 import traceback
 from dataclasses import dataclass, replace
 from weakref import WeakKeyDictionary
-from abc import ABC
 from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind, shallow_dict
 from syncraft.constraint import Bindable
 
@@ -75,12 +74,16 @@ class Error:
 
 
 @dataclass(frozen=True)        
-class Algebra(ABC, Generic[A, S]):
+class Algebra(Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################
     run_f: Callable[[S, bool], Either[Any, Tuple[A, S]]] 
     name: Hashable
     _cache: ClassVar[WeakKeyDictionary[Any, Dict[Any, object | Either[Any, Tuple[Any, Any]]]]] = WeakKeyDictionary()
 
+    @classmethod
+    def state(cls, *args:Any, **kwargs:Any)->Optional[S]: 
+        return None
+        
     def named(self, name: Hashable) -> 'Algebra[A, S]':
         return replace(self, name=name)
 

syncraft/constraint.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass, field, replace
 import collections.abc
 from collections import defaultdict
 from itertools import product
+import inspect
 
 K = TypeVar('K')
 V = TypeVar('V')
@@ -33,85 +34,23 @@ class FrozenDict(collections.abc.Mapping, Generic[K, V]):
 
     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, ...]:
-        if self._root is None:
-            raise ValueError("_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:
+    bindings : frozenset[Tuple[str, Any]] = frozenset()
+    def bind(self, name: str, node: Any) -> Binding:
         new_binding = set(self.bindings)
-        new_binding.add((var, node))
+        new_binding.add((name, node))
         return Binding(bindings=frozenset(new_binding))
     
-    def to_dict(self)->BoundVar:
+    def bound(self)->FrozenDict[str, Tuple[Any, ...]]:
         ret = defaultdict(list)
-        for var, node in self.bindings:
-            ret[var].append(node)
+        for name, node in self.bindings:
+            ret[name].append(node)
         return FrozenDict({k: tuple(vs) for k, vs in ret.items()})
 
 
-A = TypeVar('A')
+
 @dataclass(frozen=True)
 class Bindable:
     binding: Binding = field(default_factory=Binding)
@@ -119,8 +58,8 @@ class Bindable:
     def map(self, f: Callable[[Any], Any])->Self: 
         return self
     
-    def bind(self, var: Variable, node:Any)->Self:
-        return replace(self, binding=self.binding.bind(var, node))
+    def bind(self, name: str, node:Any)->Self:
+        return replace(self, binding=self.binding.bind(name, node))
 
 
 class Quantifier(Enum):
@@ -128,71 +67,105 @@ class Quantifier(Enum):
     EXISTS = "exists"
 
 @dataclass(frozen=True)
+class ConstraintResult:
+    result: bool
+    unbound: frozenset[str] = frozenset()
+@dataclass(frozen=True)
 class Constraint:
-    run_f: Callable[[BoundVar], bool]
+    run_f: Callable[[FrozenDict[str, Tuple[Any, ...]]], ConstraintResult]
     name: str = ""
-    def __call__(self, bound: BoundVar)->bool:
+    def __call__(self, bound: FrozenDict[str, Tuple[Any, ...]])->ConstraintResult:
         return self.run_f(bound)
     def __and__(self, other: Constraint) -> Constraint:
+        def and_run(bound: FrozenDict[str, Tuple[Any, ...]]) -> ConstraintResult:
+            res1 = self(bound)
+            res2 = other(bound)
+            combined_result = res1.result and res2.result
+            combined_unbound = res1.unbound.union(res2.unbound)
+            return ConstraintResult(result=combined_result, unbound=combined_unbound)
         return Constraint(
-            run_f=lambda bound: self(bound) and other(bound),
+            run_f=and_run,
             name=f"({self.name} && {other.name})"
         )
     def __or__(self, other: Constraint) -> Constraint:
+        def or_run(bound: FrozenDict[str, Tuple[Any, ...]]) -> ConstraintResult:
+            res1 = self(bound)
+            res2 = other(bound)
+            combined_result = res1.result or res2.result
+            combined_unbound = res1.unbound.union(res2.unbound)
+            return ConstraintResult(result=combined_result, unbound=combined_unbound)
         return Constraint(
-            run_f=lambda bound: self(bound) or other(bound),
+            run_f=or_run,
             name=f"({self.name} || {other.name})"
         )
     def __xor__(self, other: Constraint) -> Constraint:
+        def xor_run(bound: FrozenDict[str, Tuple[Any, ...]]) -> ConstraintResult:
+            res1 = self(bound)
+            res2 = other(bound) 
+            combined_result = res1.result ^ res2.result
+            combined_unbound = res1.unbound.union(res2.unbound)
+            return ConstraintResult(result=combined_result, unbound=combined_unbound)
         return Constraint(
-            run_f=lambda bound: self(bound) ^ other(bound),
+            run_f=xor_run,
             name=f"({self.name} ^ {other.name})"
         )
     def __invert__(self) -> Constraint:
+        def invert_run(bound: FrozenDict[str, Tuple[Any, ...]]) -> ConstraintResult:
+            res = self(bound)
+            return ConstraintResult(result=not res.result, unbound=res.unbound)
         return Constraint(
-            run_f=lambda bound: not self(bound),
+            run_f=invert_run,
             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)
+    def predicate(cls, 
+                  f: Callable[..., bool],
+                  *, 
+                  name: Optional[str] = None, 
+                  quant: Quantifier = Quantifier.FORALL)->Constraint:
+        sig = inspect.signature(f)
+        pos_params = []
+        kw_params = []
+        for pname, param in sig.parameters.items():
+            if param.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD):
+                pos_params.append(pname)
+            elif param.kind == inspect.Parameter.KEYWORD_ONLY:
+                kw_params.append(pname)
+            else:
+                raise TypeError(f"Unsupported parameter kind: {param.kind}")
+        def run_f(bound: FrozenDict[str, Tuple[Any, ...]]) -> ConstraintResult:
+            # positional argument values
+            pos_values = [bound.get(pname, ()) for pname in pos_params]
+            # keyword argument values
+            kw_values = [bound.get(pname, ()) for pname in kw_params]
+
+            # If any param is unbound, fail
+            all_params = pos_params + kw_params
+            all_values = pos_values + kw_values
+            unbound_args = [p for p, vs in zip(all_params, all_values) if not vs]
+            if unbound_args:
+                return ConstraintResult(result=quant is Quantifier.FORALL, unbound=frozenset(unbound_args))
+
+            # Cartesian product
+            all_combos = product(*pos_values, *kw_values)
+
+            def eval_combo(combo):
+                pos_args = combo[: len(pos_values)]
+                kw_args = dict(zip(kw_params, combo[len(pos_values) :]))
+                return f(*pos_args, **kw_args)
+
+            if quant is Quantifier.EXISTS:
+                return ConstraintResult(result = any(eval_combo(c) for c in all_combos), unbound=frozenset())
+            else:
+                return ConstraintResult(result = all(eval_combo(c) for c in all_combos), unbound=frozenset())
+
+        return cls(run_f=run_f, name=name or f.__name__)
+
+def forall(f: Callable[..., bool], name: Optional[str] = None) -> Constraint:
+    return Constraint.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)
+def exists(f: Callable[..., bool], name: Optional[str] = None) -> Constraint:
+    return Constraint.predicate(f, name=name, quant=Quantifier.EXISTS)
 
 

syncraft/generator.py

@@ -16,14 +16,14 @@ from syncraft.ast import (
     Choice, Many, ChoiceKind,
     Then, ThenKind, Marked
 )
-
+from syncraft.constraint import FrozenDict
 from syncraft.syntax import Syntax
 from sqlglot import TokenType
 import re
 import rstr
 from functools import lru_cache
 import random
-from rich import print
+
 from syncraft.constraint import Bindable
 
 T = TypeVar('T', bound=TokenProtocol)  
@@ -144,6 +144,10 @@ class TokenGen(TokenSpec):
 
 @dataclass(frozen=True)
 class Generator(Algebra[ParseResult[T], GenState[T]]):  
+    @classmethod
+    def state(cls, ast: Optional[ParseResult[T]] = None, seed: int = 0, restore_pruned: bool = False)->GenState[T]:
+        return GenState.from_ast(ast=ast, seed=seed, restore_pruned=restore_pruned)
+
     def flat_map(self, f: Callable[[ParseResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
         def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
             try:
@@ -293,14 +297,9 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
 def generate(syntax: Syntax[Any, Any], 
             data: Optional[ParseResult[Any]] = None, 
             seed: int = 0, 
-            restore_pruned: bool = False) -> AST | Any:
-    gen = syntax(Generator)
-    state = GenState.from_ast(ast=data, seed=seed, restore_pruned=restore_pruned)
-    result = gen.run(state, use_cache=False)
-    if isinstance(result, Right):
-        return result.value[0]
-    assert isinstance(result, Left), "Generator must return Either[Any, Tuple[Any, Any]]"
-    return result.value
+            restore_pruned: bool = False) -> Tuple[AST, FrozenDict[str, AST]] | Tuple[Any, None]:
+    from syncraft.syntax import run
+    return run(syntax, Generator, False, ast=data, seed=seed, restore_pruned=restore_pruned)
 
 
     

syncraft/parser.py

@@ -5,6 +5,7 @@ from typing import (
     Optional, List, Any, Tuple, TypeVar,
     Generic
 )
+from syncraft.constraint import FrozenDict
 from syncraft.algebra import (
     Either, Left, Right, Error, Algebra
 )
@@ -67,6 +68,11 @@ class ParserState(Bindable, Generic[T]):
     
 @dataclass(frozen=True)
 class Parser(Algebra[T, ParserState[T]]):
+    @classmethod
+    def state(cls, sql: str, dialect: str) -> ParserState[Token]:
+        tokens = tuple([Token(token_type=token.token_type, text=token.text) for token in tokenize(sql, dialect=dialect)])
+        return ParserState.from_tokens(tokens) 
+
     @classmethod
     def token(cls, 
               token_type: Optional[Enum] = None, 
@@ -182,21 +188,12 @@ def sqlglot(parser: Syntax[Any, Any],
     return parser.map(lambda tokens: [e for e in gp.parse(raw_tokens=tokens) if e is not None])
 
 
-def parse(syntax: Syntax[Any, Any], 
-          sql: str, 
-          dialect: str) -> AST | Any:
-    parser = syntax(Parser)
-    input: ParserState[Token] = token_state(sql, dialect=dialect)
-    result = parser.run(input, True)
-    if isinstance(result, Right):
-        return result.value[0]
-    assert isinstance(result, Left), "Parser must return Either[E, Tuple[A, S]]"
-    return result.value
+def parse(syntax: Syntax[Any, Any], sql: str, dialect: str) -> Tuple[AST, FrozenDict[str, AST]] | Tuple[Any, None]:
+    from syncraft.syntax import run
+    return run(syntax, Parser, True, sql=sql, dialect=dialect)
+
 
 
-def token_state(sql: str, dialect: str) -> ParserState[Token]:
-    tokens = tuple([Token(token_type=token.token_type, text=token.text) for token in tokenize(sql, dialect=dialect)])
-    return ParserState.from_tokens(tokens) 
 
 def token(token_type: Optional[Enum] = None, 
           text: Optional[str] = None, 

syncraft/syntax.py

@@ -2,18 +2,23 @@ from __future__ import annotations
 
 from typing import (
     Optional, Any, TypeVar, Generic, Callable, Tuple, cast,
-    Type, Literal, List, overload
+    Type, Literal, List
 )
 from dataclasses import dataclass, field, replace
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Right
-from syncraft.constraint import Variable, Bindable
+from syncraft.algebra import Algebra, Error, Either, Right, Left
+from syncraft.constraint import Bindable, FrozenDict
 from syncraft.ast import Then, ThenKind, Marked, Choice, Many, ChoiceKind, Nothing, Collect, E, Collector
 from types import MethodType, FunctionType
+import keyword
 
-from rich import print
 
 
+def valid_name(name: str) -> bool:
+    return (name.isidentifier() 
+            and not keyword.iskeyword(name)
+            and not (name.startswith('__') and name.endswith('__')))
+
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Result type for mapping
 C = TypeVar('C')  # Result type for else branch
@@ -249,27 +254,18 @@ class Syntax(Generic[A, S]):
         return self.optional()
 
 
-######################################################################## data processing combinators #########################################################
-    @overload
-    def bind(self,
-             var: Variable, 
-             collector: None = None)-> Syntax[A | Marked[A], S]: ...
-    
-    @overload
-    def bind(self,
-             var: Variable,
-             collector: Type[E]) -> Syntax[Collect[A, E] | Marked[Collect[A, E]], S]: ...
-             
-    def bind(self, 
-             var: Variable, 
-             collector: Optional[Type[E]]=None) -> Syntax[Any, S]:
+######################################################################## data processing combinators #########################################################             
+    def bind(self, name: Optional[str] = None) -> Syntax[A, S]:
+        if name:
+            assert valid_name(name), f"Invalid mark name: {name}"
         def bind_v(v: Any, s: S)->Tuple[Any, S]:
-            return v, s.bind(var, v)
-        if callable(collector):
-            ret = self.to(collector).mark(var.name).map_all(bind_v) if var.name else self.to(collector).map_all(bind_v) 
-        else:
-            ret = self.mark(var.name).map_all(bind_v) if var.name else self.map_all(bind_v)
-        return ret.describe(name=f'bind({var.name})', fixity='postfix', parameter=(self,))
+            if name:
+                return v, s.bind(name, v) 
+            elif isinstance(v, Marked):
+                return v.value, s.bind(v.name, v.value)
+            else:
+                return v, s
+        return self.map_all(bind_v).describe(name=f'bind({name})', fixity='postfix', parameter=(self,))
 
     def to(self, f: Collector[E])-> Syntax[Collect[A, E], S]:
         def to_f(v: A) -> Collect[A, E]:
@@ -283,15 +279,16 @@ class Syntax(Generic[A, S]):
 
 
     def mark(self, name: str) -> Syntax[Marked[A], S]:
-        def bind_s(value: A) -> Marked[A]:
+        assert valid_name(name), f"Invalid mark name: {name}"
+        def mark_s(value: A) -> Marked[A]:
             if isinstance(value, Marked):
                 return replace(value, name=name)    
             else:
                 return Marked(name=name, value=value)
-        def ibind_s(m : Marked[A]) -> A:
+        def imark_s(m : Marked[A]) -> A:
             return m.value if isinstance(m, Marked) else m
             
-        return self.bimap(bind_s, ibind_s).describe(name=f'bind("{name}")', fixity='postfix', parameter=(self,))
+        return self.bimap(mark_s, imark_s).describe(name=f'mark("{name}")', fixity='postfix', parameter=(self,))
 
 
 
@@ -322,50 +319,15 @@ def success(value: Any) -> Syntax[Any, Any]:
 def choice(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
     return reduce(lambda a, b: a | b, parsers) if len(parsers) > 0 else success(Nothing())
 
-
-def all(*parsers: Syntax[Any, S]) -> Syntax[Then[Any, Any], S]:
-    return reduce(lambda a, b: a + b, parsers) if len(parsers) > 0 else success(Nothing())
-
-def first(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
-    return reduce(lambda a, b: a // b, parsers) if len(parsers) > 0 else success(Nothing())
-
-def last(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
-    return reduce(lambda a, b: a >> b, parsers) if len(parsers) > 0 else success(Nothing())
-
-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, Variable)) and isinstance(x[1], Syntax)
-    
-    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:
-            raise ValueError(f"Invalid parser or tuple: {x}", x)
-    ret: Optional[Syntax[Any, S]] = None
-    has_data = False
-    for p in parsers:
-        just_parser = to_parser(p)
-        if has_data:
-            if ret is not None:
-                if is_named_parser(p):
-                    ret = ret + just_parser
-                else:
-                    ret = ret // just_parser
-            else:
-                ret = just_parser
-        else:
-            has_data = is_named_parser(p)
-            if ret is None:
-                ret = just_parser
-            else:
-                ret = ret >> just_parser
-    
-    return ret if ret is not None else success(Nothing()) 
+def run(syntax: Syntax[A, S], alg: Type[Algebra[A, S]], use_cache:bool, *args: Any, **kwargs: Any) -> Tuple[Any, FrozenDict[str, Any]] | Tuple[Any, None]:
+    parser = syntax(alg)
+    input: Optional[S] = alg.state(*args, **kwargs)
+    if input:
+        result = parser.run(input, use_cache=use_cache)
+        if isinstance(result, Right):
+            return result.value[0], result.value[1].binding.bound()
+        assert isinstance(result, Left), "Algebra must return Either[E, Tuple[A, S]]"
+        return result.value, None
+    else:
+        return Error(this=None, message="Algebra failed to create initial state"), None
 

{syncraft-0.1.38.dist-info → syncraft-0.2.1.dist-info}/METADATA

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

syncraft-0.2.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=2pyxbllcRsaDS_rEXfagBenZ_etSjMNdlVYxPkoU7cQ,15849
+syncraft/ast.py,sha256=TAHj8IOgx_QtlI4zxFr2DRGZ4dwNGsb6TiH0TH9adIg,14556
+syncraft/constraint.py,sha256=9VvnZtL3Q63qnU-j3cgTQm8cMrIXdgSgl4qIEF-YCx4,6509
+syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
+syncraft/finder.py,sha256=Wr7wiBuO9IaXBmYBA4DNXmoeEWteRIp-UetnuRScapM,1920
+syncraft/generator.py,sha256=inNBE4dk1AHXCCgnBHsgVOuHRIsHXIY1BXnpy1oLq8s,13062
+syncraft/parser.py,sha256=XjLEkPnOb8YwlIJeqtn9VT6oAWLu_otD2H_o4utZP5I,11270
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=qqPOxcelIwFNyzLdTKkQVtUzzz1Xkv0wEBJQ9vt8HTc,16282
+syncraft-0.2.1.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.2.1.dist-info/METADATA,sha256=ByoEIvwRb64_WH9MDoMJqJeEpwCqyJYi1OP9FJHNgsk,988
+syncraft-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.2.1.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.2.1.dist-info/RECORD,,

syncraft-0.1.38.dist-info/RECORD

@@ -1,16 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=U28UIKK4oh2yIuvOqKYeo4_lDkX3Sy_nHSaHnIabcbk,15769
-syncraft/ast.py,sha256=TAHj8IOgx_QtlI4zxFr2DRGZ4dwNGsb6TiH0TH9adIg,14556
-syncraft/constraint.py,sha256=eTXINghioXmJzAtW3jM-Q_TW2LYXu6mUDq34KlI_x-w,6440
-syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
-syncraft/finder.py,sha256=Wr7wiBuO9IaXBmYBA4DNXmoeEWteRIp-UetnuRScapM,1920
-syncraft/generator.py,sha256=C0vpJotp982anrSXq1-EdjQU_OMI_vDCa7uTdJK8M5M,12987
-syncraft/parser.py,sha256=RkQwFv00rOI-n4kvG4baGVTdK46T-_Hw7OJ0FB7g72g,11379
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=RxRdXR0KF5awmbaumfpkb1rvgMuCl0nhVIm3V20MB-U,17699
-syncraft-0.1.38.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.38.dist-info/METADATA,sha256=aO928d0qKdo3EiiNIfeAIoAnbKs84902-TKwHZ2B9JU,989
-syncraft-0.1.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.38.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.38.dist-info/RECORD,,