syncraft 0.2.4__tar.gz → 0.2.5__tar.gz

{syncraft-0.2.4/syncraft.egg-info → syncraft-0.2.5}/PKG-INFO

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

{syncraft-0.2.4 → syncraft-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "syncraft"
-version = "0.2.4"
+version = "0.2.5"
 description = "Parser combinator library"
 license = "MIT"
 license-files = ["LICENSE"]

{syncraft-0.2.4 → syncraft-0.2.5}/syncraft/constraint.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Callable, Generic, Tuple, TypeVar, Optional, Any, Self
+from typing import Callable, Generic, Tuple, TypeVar, Optional, Any, Self, Generator
 from enum import Enum
 from dataclasses import dataclass, field, replace
 import collections.abc
@@ -20,6 +20,19 @@ class FrozenDict(collections.abc.Mapping, Generic[K, V]):
     def __init__(self, *args, **kwargs):
         self._data = dict(*args, **kwargs)
         self._hash = None
+
+    def __or__(self, other: collections.abc.Mapping) -> "FrozenDict[K, V]":
+        """Return a new FrozenDict with merged keys (other overrides self)."""
+        merged = dict(self._data)
+        merged.update(other)
+        return FrozenDict(merged)
+
+    def __ror__(self, other: collections.abc.Mapping) -> "FrozenDict[K, V]":
+        """Support other | self."""
+        merged = dict(other)
+        merged.update(self._data)
+        return FrozenDict(merged)
+            
     def __getitem__(self, key):
         return self._data[key]
 
@@ -230,3 +243,145 @@ def exists(f: Callable[..., bool], name: Optional[str] = None, bimap:bool = True
 
 
 
+def all_binding(a: FrozenDict[str, Tuple[Any, ...]], *names: str) -> Generator[FrozenDict[str, Any], None, None]:
+    """Yield all combinations of the provided bindings."""
+    if a:
+        names = tuple(a.keys()) if not names else names 
+        values = [a[name] for name in names]
+        for combo in product(*values):
+            yield FrozenDict({name: value for name, value in zip(names, combo)})
+
+
+    
+
+
+
+
+
+@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)
+
+
+

{syncraft-0.2.4 → syncraft-0.2.5}/syncraft/generator.py

@@ -454,29 +454,57 @@ 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) -> Tuple[AST, FrozenDict[str, Tuple[AST, ...]]] | Tuple[Any, None]:
-    """Run a ``Syntax`` with the ``Generator`` backend.
+def generate_with(
+    syntax: Syntax[Any, Any], 
+    data: Optional[ParseResult[Any]] = None, 
+    seed: int = 0, 
+    restore_pruned: bool = False
+) -> Tuple[AST, FrozenDict[str, Tuple[AST, ...]]] | Tuple[Any, None]:
+    """
+    Generate an AST from the given syntax, optionally constrained by a partial parse result.
 
-    In validation mode (``data`` provided), walks the structure and returns the
-    original AST and collected marks. In generation mode (``data`` is ``None``),
-    synthesizes an AST from the syntax using the given seed.
+    Args:
+        syntax: The syntax specification to generate from.
+        data: An optional partial parse result (AST) to constrain generation.
+        seed: Random seed for reproducibility.
+        restore_pruned: Whether to restore pruned branches in the AST.
+
+    Returns:
+        A tuple of (AST, variable bindings) if successful, or (None, None) on failure.
+    """
+    from syncraft.syntax import run
+    return run(syntax, Generator, not restore_pruned, ast=data, seed=seed, restore_pruned=restore_pruned)
+
+
+def validate(
+    syntax: Syntax[Any, Any], 
+    data: ParseResult[Any]
+) -> Tuple[AST, FrozenDict[str, Tuple[AST, ...]]] | Tuple[Any, None]:
+    """
+    Validate a parse result (AST) against the given syntax.
 
     Args:
-        syntax: The syntax to execute.
-        data: Optional root AST to validate against.
-        seed: Seed for deterministic random generation.
-        restore_pruned: Allow traversing pruned branches when validating.
+        syntax: The syntax specification to validate against.
+        data: The parse result (AST) to validate.
 
     Returns:
-        Tuple[AST, FrozenDict[str, Tuple[AST, ...]]] | Tuple[Any, None]: The
-        resulting AST with marks when validating, or a synthesized AST when
-        generating.
+        A tuple of (AST, variable bindings) if valid, or (None, None) if invalid.
     """
     from syncraft.syntax import run
-    return run(syntax, Generator, False, ast=data, seed=seed, restore_pruned=restore_pruned)
+    return run(syntax, Generator, True, ast=data, seed=0, restore_pruned=True)
+
+
+def generate(
+    syntax
+) -> Tuple[AST, FrozenDict[str, Tuple[AST, ...]]] | Tuple[Any, None]:
+    """
+    Generate a random AST that conforms to the given syntax.
 
+    Args:
+        syntax: The syntax specification to generate from.
 
-    
+    Returns:
+        A tuple of (AST, variable bindings) if successful, or (None, None) on failure.
+    """
+    from syncraft.syntax import run
+    return run(syntax, Generator, False, ast=None, seed=random.randint(0, 2**32 - 1), restore_pruned=False)

{syncraft-0.2.4 → syncraft-0.2.5/syncraft.egg-info}/PKG-INFO

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