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

syncraft/ast.py

@@ -13,9 +13,16 @@ from dataclasses import dataclass, replace, is_dataclass, fields
 from enum import Enum
 
 
+class SyncraftError(Exception):
+    def __init__(self, message: str, offending: Any, expect: Any = None, **kwargs: Any) -> None:
+        super().__init__(message)
+        self.offending = offending
+        self.expect = expect
+        self.data = kwargs
+
 def shallow_dict(a: Any)->Dict[str, Any]:
     if not is_dataclass(a):
-        raise ValueError(f"Expected dataclass instance for collector inverse, got {type(a)}")
+        raise SyncraftError("Expected dataclass instance for collector inverse", offending=a, expect="dataclass")
     return {f.name: getattr(a, f.name) for f in fields(a)}
 
 
@@ -130,7 +137,7 @@ class Bimap(Generic[A, B]):
                 return c, inv
             return Bimap(bimap_then_run)
         else:
-            raise TypeError(f"Unsupported type for Bimap >>: {type(other)}")
+            raise SyncraftError("Unsupported type for Bimap >>", offending=other, expect=(Bimap , Biarrow))
     def __rrshift__(self, other: Bimap[C, A] | Biarrow[C, A]) -> Bimap[C, B]:
         """Right-composition so arrows or bimaps can be on the left of ``>>``."""
         if isinstance(other, Biarrow):
@@ -152,7 +159,7 @@ class Bimap(Generic[A, B]):
                 return b2, inv
             return Bimap(bimap_then_run)
         else:
-            raise TypeError(f"Unsupported type for Bimap <<: {type(other)}")
+            raise SyncraftError("Unsupported type for Bimap <<", offending=other, expect=(Bimap , Biarrow))
 
 
     @staticmethod
@@ -397,7 +404,7 @@ class Collect(Generic[A, E], AST):
 
         def inv_one_positional(e: E) -> B:
             if not is_dataclass(e):
-                raise ValueError(f"Expected dataclass instance for collector inverse, got {type(e)}")
+                raise SyncraftError("Expected dataclass instance for collector inverse", offending=e, expect="dataclass")
             named_dict = shallow_dict(e)
             return named_dict[fields(e)[0].name]
 
@@ -417,7 +424,7 @@ class Collect(Generic[A, E], AST):
                 ret: E = self.collector(*unnamed, **named)
                 def invf(e: E) -> Tuple[Any, ...]:
                     if not is_dataclass(e):
-                        raise ValueError(f"Expected dataclass instance for collector inverse, got {type(e)}")
+                        raise SyncraftError("Expected dataclass instance for collector inverse", offending=e, expect="dataclass")
                     named_dict = shallow_dict(e)     
                     unnamed = []           
                     for f in fields(e):
@@ -432,6 +439,21 @@ class Collect(Generic[A, E], AST):
                     return tuple(tmp)
                 return ret, lambda e: replace(self, value=inner_f(invf(e))) # type: ignore                
         return self.collector(b), lambda e: replace(self, value=inner_f(inv_one_positional(e))) # type: ignore
+    
+
+
+@dataclass(frozen=True)
+class Custom(Generic[A, B], AST):
+    """A custom AST node wrapping an arbitrary value.
+
+    Used when the parse result does not fit into other AST node types.
+    """
+    meta: B
+    value: A
+    def bimap(self, r: Bimap[A, C]=Bimap.identity()) -> Tuple[C, Callable[[C], Custom[A, B]]]:
+        """Defer to the provided mapping ``r``."""
+        v, inv = r(self.value)
+        return v, lambda c: replace(self, value=inv(c))
 
 #########################################################################################################################
 @dataclass(frozen=True)
@@ -455,13 +477,46 @@ class TokenProtocol(Protocol):
 T = TypeVar('T', bound=TokenProtocol)  
 
 
+
+@dataclass(frozen=True)
+class SyntaxSpec:
+    pass
+@dataclass(frozen=True)
+class ChoiceSpec(SyntaxSpec, Generic[A, B]):
+    left: A
+    right: B
+
+@dataclass(frozen=True)
+class LazySpec(SyntaxSpec, Generic[A]):
+    value: A
+@dataclass(frozen=True)
+class ThenSpec(SyntaxSpec, Generic[A, B]):
+    left: A
+    right: B
+
 @dataclass(frozen=True)
-class TokenSpec:
+class ManySpec(SyntaxSpec, Generic[A]):
+    value: A
+    at_least: int
+    at_most: Optional[int]
+
+
+@dataclass(frozen=True)
+class TokenSpec(SyntaxSpec):
     token_type: Optional[Enum] = None
     text: Optional[str] = None
     case_sensitive: bool = False
     regex: Optional[re.Pattern[str]] = None
-        
+
+    @classmethod
+    def create(cls, 
+               *, 
+               token_type: Optional[Enum] = None, 
+               text: Optional[str] = None, 
+               case_sensitive: bool = False, 
+               regex: Optional[re.Pattern[str]] = None) -> TokenSpec:
+        return cls(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)
+
     def is_valid(self, token: TokenProtocol) -> bool:
         type_match = self.token_type is None or token.token_type == self.token_type
         value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 

syncraft/cache.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, TypeVar, Hashable, Generic, Callable, Any, Generator, overload, Literal
+from weakref import WeakKeyDictionary
+from syncraft.ast import SyncraftError
+
+
+class RecursionError(SyncraftError):
+    def __init__(self, message: str, offending: Any, expect: Any = None, **kwargs: Any) -> None:
+        super().__init__(message, offending, expect, **kwargs)
+
+
+@dataclass(frozen=True)
+class InProgress:
+    _instance = None
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(InProgress, cls).__new__(cls)
+        return cls._instance
+    def __str__(self)->str:
+        return self.__class__.__name__
+    def __repr__(self)->str:
+        return self.__str__()
+
+
+
+
+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)
+
+    def __contains__(self, f: Callable[..., Any]) -> bool:
+        return f in self.cache
+
+    def __repr__(self) -> str:
+        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]:
+        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
+
+    @overload
+    def _execute(self, 
+                 f: Callable[[Args, bool], Ret], 
+                 args: Args, 
+                 use_cache: bool, 
+                 is_gen: Literal[False]) -> 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]: ...
+
+
+    def _execute(self, 
+            f: Callable[[Args, bool], Any], 
+            args: Args, 
+            use_cache:bool,
+            is_gen: bool
+            ) -> 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]
+            if isinstance(v, InProgress):
+                raise RecursionError("Left-recursion detected in parser", offending=f, state=args)
+            else:
+                return v        
+        try:
+            c[args] = InProgress()
+            if is_gen:
+                result = yield from f(args, use_cache)
+            else:
+                result = f(args, use_cache)
+            c[args] = result
+            if not use_cache:
+                c.pop(args, None)
+            return result
+        except Exception as e:
+            c.pop(args, 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)) 
+
+    def call(self, 
+            f: Callable[[Args, bool], Ret], 
+            args: Args, 
+            use_cache:bool) -> Ret:
+        return self._execute(f, args, use_cache, is_gen=False) 
+
+

syncraft/constraint.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
-from typing import Callable, Generic, Tuple, TypeVar, Optional, Any, Self, Generator
+from typing import (
+    Callable, Generic, Tuple, TypeVar, Optional, Any, Self, 
+    Generator, List, Set, Union, Dict, Iterable,
+)
 from enum import Enum
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field, replace, is_dataclass, fields
 import collections.abc
 from collections import defaultdict
 from itertools import product
 from inspect import Signature
 import inspect
-
+from syncraft.ast import SyncraftError
 K = TypeVar('K')
 V = TypeVar('V')
 class FrozenDict(collections.abc.Mapping, Generic[K, V]):
@@ -171,7 +174,9 @@ class Constraint:
             elif param.kind == inspect.Parameter.KEYWORD_ONLY:
                 kw_params.append(pname)
             else:
-                raise TypeError(f"Unsupported parameter kind: {param.kind}")
+                raise SyncraftError(f"Unsupported parameter kind: {param.kind}", 
+                                    offending=param.kind, 
+                                    expect=(inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY))
         def run_f(bound: FrozenDict[str, Tuple[Any, ...]]) -> ConstraintResult:
             # positional argument values
             pos_values = [bound.get(pname, ()) for pname in pos_params]
@@ -254,134 +259,179 @@ def all_binding(a: FrozenDict[str, Tuple[Any, ...]], *names: str) -> Generator[F
 
     
 
-
-
-
-
+####################################################################################################################################
 @dataclass(frozen=True)
-class Relation:
-    run_f: Callable[[FrozenDict[str, Tuple[Any, ...]]], Generator[FrozenDict[str, Any], None, None]]
-    name: str = ""
-    args: frozenset[str]=field(default_factory=frozenset)
-
-    def __call__(self, bound: FrozenDict[str, Tuple[Any, ...]])->Generator[FrozenDict[str, Any], None, None]:
-        yield from self.run_f(bound)
-
-    def __and__(self, other: Relation) -> Relation:
-        def and_run(bound: FrozenDict[str, tuple]) -> Generator[FrozenDict[str, Any], None, None]:
-            for res1 in self(bound):
-                for res2 in other(bound):
-                    merged = res1 | res2
-                    if len(merged) == len(res1) + len(res2):
-                        yield FrozenDict(merged)
-        return Relation(
-            run_f=and_run,
-            args = self.args.union(other.args),
-            name=f"({self.name} && {other.name})"
-        )
-    
-    def __or__(self, other: Relation) -> Relation:
-        def or_run(bound: FrozenDict[str, tuple]) -> Generator[FrozenDict[str, Any], None, None]:
-            yield from self(bound)
-            yield from other(bound)
-        return Relation(
-            run_f=or_run,
-            name=f"({self.name} || {other.name})"
-        )
-    
-    def __xor__(self, other: "Relation") -> "Relation":
-        def xor_run(bound: FrozenDict[str, tuple]) -> Generator[FrozenDict[str, Any], None, None]:
-            self_results = list(self(bound))
-            other_results = list(other(bound))
-            # yield from self only if not in other
-            for res1 in self_results:
-                if res1 not in other_results:
-                    yield res1
-            # yield from other only if not in self
-            for res2 in other_results:
-                if res2 not in self_results:
-                    yield res2
-
-        return Relation(
-            run_f=xor_run,
-            name=f"({self.name} ^ {other.name})"
-        )    
-
-    @classmethod
-    def predicate(cls, 
-                  f: Callable[..., bool],
-                  *, 
-                  sig: Signature,
-                  name: str)->Relation:
-        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, ...]]) -> Generator[FrozenDict[str, Any], None, None]:
-            # 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 not unbound_args:
-                # Cartesian product
-                for combo in product(*pos_values, *kw_values):
-                    pos_args = combo[: len(pos_values)]
-                    kw_args = dict(zip(kw_params, combo[len(pos_values) :]))
-                    if f(*pos_args, **kw_args):
-                        binding_dict = {name: arg for name, arg in zip(all_params, combo)}
-                        yield FrozenDict(binding_dict)
-
-        return cls(run_f=run_f, name=name)
-
-
-def relation(f: Callable[..., bool], 
-              *, 
-              name: Optional[str] = None, 
-              bimap: bool = True) -> Relation:
-    name = name or f.__name__
-    sig = inspect.signature(f)
-    if bimap:
-        def wrapper(*args: Any, **kwargs:Any) -> bool:
-            mapped_args = [a.bimap()[0] if hasattr(a, "bimap") else a for a in args]
-            mapped_kwargs = {k: (v.bimap()[0] if hasattr(v, "bimap") else v) for k,v in kwargs.items()}
-            return f(*mapped_args, **mapped_kwargs)
-        return Relation.predicate(wrapper, sig=sig, name=name)
-    else:
-        return Relation.predicate(f, sig=sig, name=name)
-
-
-def xforall(f: Callable[..., bool], *, name: str) -> Relation:
-    base_constraint = relation(f, name=name)
-
-    def run_f(bound: FrozenDict[str, Tuple[Any, ...]]) -> Generator[FrozenDict[str, Any], None, None]:
-        # Collect all satisfying bindings
-        all_bindings = list(base_constraint(bound))
-
-        # For FORALL, yield only if all combinations succeed
-        if all_bindings:
-            for b in all_bindings:
-                yield b
-        # If no bindings satisfy, nothing is yielded (FORALL fails)
-
-    return Relation(run_f=run_f, name=name)
-
-
-def xexists(f: Callable[..., bool], *, name: str) -> Relation:
-    def run_f(bound: FrozenDict[str, Tuple[Any, ...]]) -> Generator[FrozenDict[str, Any], None, None]:
-        # For EXISTS, yield only the first satisfying binding
-        for b in relation(f, name=name)(bound):
-            yield b
-            return  # stop at first satisfying tuple
-    return Relation(run_f=run_f, name=name)
-
-
-
+class Var:
+    name: str
+
+
+Subst = Dict[str, Any]
+Fact = Tuple[str, Tuple[Any, ...]]
+Rule = Tuple[str, Tuple[Any, ...], List[Fact]]
+
+def is_var(x): return isinstance(x, Var)
+
+# ---------- Unification ----------
+def unify(x, y, subst: Subst) -> Subst | None:
+    if x == y:
+        return subst
+    if is_var(x):
+        return unify_var(x, y, subst)
+    if is_var(y):
+        return unify_var(y, x, subst)
+    if isinstance(x, tuple) and isinstance(y, tuple) and len(x) == len(y):
+        for a, b in zip(x, y):
+            tmp = unify(a, b, subst)
+            if tmp is None:
+                return None
+            else: 
+                subst = tmp
+        return subst
+    return None
+
+def unify_var(var: Var, val: Any, subst: Subst) -> Subst | None:
+    if var.name in subst:
+        return unify(subst[var.name], val, subst)
+    if occurs_check(var, val, subst):
+        return None
+    subst = subst.copy()
+    subst[var.name] = val
+    return subst
+
+def occurs_check(var: Var, val: Any, subst: Subst) -> bool:
+    if var == val: 
+        return True
+    if is_var(val) and val.name in subst:
+        return occurs_check(var, subst[val.name], subst)
+    if isinstance(val, tuple):
+        return any(occurs_check(var, v, subst) for v in val)
+    return False
+
+# ---------- Substitution ----------
+def apply_subst_fact(fact: Fact, subst: Subst) -> Fact:
+    pred, args = fact
+    return (pred, tuple(apply_subst_term(a, subst) for a in args))
+
+def apply_subst_term(term, subst: Subst):
+    if is_var(term) and term.name in subst:
+        return apply_subst_term(subst[term.name], subst)
+    return term
+
+# ---------- Engine ----------
+class DatalogEngine:
+    def __init__(self):
+        self.facts: List[Fact] = []
+        self.rules: List[Rule] = []
+
+    def add_fact(self, fact: Fact):
+        self.facts.append(fact)
+
+    def add_rule(self, head: Fact, body: List[Fact]):
+        self.rules.append((head[0], head[1], body))
+
+    # ----- Forward chaining -----
+    def infer(self) -> List[Fact]:
+        changed = True
+        inferred = set(self.facts)
+        while changed:
+            changed = False
+            for (hpred, hargs, body) in self.rules:
+                for subst in self._prove_body(body, {}):
+                    head = apply_subst_fact((hpred, hargs), subst)
+                    if head not in inferred:
+                        inferred.add(head)
+                        changed = True
+        return list(inferred)
+
+    # ----- Backward chaining -----
+    def query(self, goal: Fact, subst: Subst | None = None) -> Generator[Subst, None, None]:
+        if subst is None:
+            subst = {}
+        pred, args = goal
+
+        # Match against facts
+        for (fpred, fargs) in self.facts:
+            if fpred != pred: 
+                continue
+            s = unify(args, fargs, subst)
+            if s is not None:
+                yield s
+
+        # Match against rules
+        for (hpred, hargs, body) in self.rules:
+            if hpred != pred: 
+                continue
+            s = unify(args, hargs, subst)
+            if s is None: 
+                continue
+            yield from self._prove_body(body, s)
+
+    def _prove_body(self, goals: List[Fact], subst: Subst) -> Generator[Subst, None, None]:
+        if not goals:
+            yield subst
+            return
+        first, *rest = goals
+        for s in self.query(apply_subst_fact(first, subst), subst):
+            yield from self._prove_body(rest, s)
+
+#####################################################################################################################################
+def dataclass_to_facts(obj: Any, *, extended: bool = False, parent: Any = None) -> List[Fact]:
+    facts: List[Fact] = []
+
+    if not is_dataclass(obj):
+        raise TypeError(f"Expected dataclass instance, got {type(obj)}")
+
+    cls = type(obj)
+    pred = cls.__name__  # use class name as predicate
+    args = tuple(getattr(obj, f.name) for f in fields(obj))
+    facts.append((pred, args))
+
+    for f in fields(obj):
+        val = getattr(obj, f.name)
+
+        if is_dataclass(val):
+            # recurse into child dataclass
+            facts.extend(dataclass_to_facts(val, extended=extended, parent=obj))
+
+            if extended:
+                facts.append(("Contains", (obj, val)))
+                facts.append(("Field", (obj, f.name, val)))
+
+        elif isinstance(val, list):
+            for item in val:
+                if is_dataclass(item):
+                    facts.extend(dataclass_to_facts(item, extended=extended, parent=obj))
+                    if extended:
+                        facts.append(("Contains", (obj, item)))
+                        facts.append(("Field", (obj, f.name, item)))
+                else:
+                    if extended:
+                        facts.append(("Field", (obj, f.name, item)))
+        else:
+            if extended:
+                facts.append(("Field", (obj, f.name, val)))
+
+    return facts
+
+
+
+def test()->None:
+    X, Y, Z = Var("X"), Var("Y"), Var("Z")
+
+    db = DatalogEngine()
+    db.add_fact(("parent", ("alice", "bob")))
+    db.add_fact(("parent", ("bob", "carol")))
+
+    # Rules
+    db.add_rule(("ancestor", (X, Y)), [("parent", (X, Y))])
+    db.add_rule(("ancestor", (X, Y)), [("parent", (X, Z)), ("ancestor", (Z, Y))])
+
+    print("Forward infer:")
+    print(db.infer())
+    # [('parent', ('alice', 'bob')), ('parent', ('bob', 'carol')), 
+    #  ('ancestor', ('alice', 'bob')), ('ancestor', ('bob', 'carol')), 
+    #  ('ancestor', ('alice', 'carol'))]
+
+    print("Backward query:")
+    print(list(db.query(("ancestor", (X, "carol")))))
+    # [{'X': 'bob'}, {'X': 'alice'}]

syncraft/dev.py

@@ -0,0 +1,9 @@
+from syncraft.utils import ast2svg, syntax2svg, rich_error, rich_parser, rich_debug
+
+__all__ = [
+    "ast2svg",
+    "syntax2svg",
+    "rich_error",
+    "rich_parser",
+    "rich_debug"
+]