syncraft 0.1.10__tar.gz → 0.1.12__tar.gz

{syncraft-0.1.10 → syncraft-0.1.12}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.10
+Version: 0.1.12
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
 Keywords: parser,combinator,sql,sqlite,generator,printer
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rich>=14.1.0

{syncraft-0.1.10 → syncraft-0.1.12}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "syncraft"
-version = "0.1.10"
+version = "0.1.12"
 description = "Parser combinator library"
 license = "MIT"
 license-files = ["LICENSE"]
 readme = "README.md"
 authors = [{name = "Michael Afmokt", email = "michael@esacca.com"}]
 keywords = ["parser", "combinator", "sql", "sqlite", "generator", 'printer']
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
     "rich>=14.1.0",
     "rstr>=3.2.2",

syncraft-0.1.12/syncraft/ast.py

@@ -0,0 +1,202 @@
+
+
+from __future__ import annotations
+import re
+from typing import (
+    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
+    Protocol, Generic, Callable, Union
+)
+from syncraft.algebra import (
+    NamedResult, OrResult,ThenResult, ManyResult, ThenKind,
+    Lens
+)
+from dataclasses import dataclass, field, replace, is_dataclass, asdict
+from enum import Enum
+from functools import cached_property
+
+@runtime_checkable
+class TokenProtocol(Protocol):
+    @property
+    def token_type(self) -> Enum: ...
+    @property
+    def text(self) -> str: ...
+    
+
+@dataclass(frozen=True)
+class Token:
+    token_type: Enum
+    text: str
+    def __str__(self) -> str:
+        return f"{self.token_type.name}({self.text})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+@dataclass(frozen=True)
+class TokenSpec:
+    token_type: Optional[Enum] = None
+    text: Optional[str] = None
+    case_sensitive: bool = False
+    regex: Optional[re.Pattern[str]] = None
+        
+    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 
+                                                    token.text.strip().upper() == self.text.strip().upper())
+        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
+        return type_match and value_match
+
+
+
+
+T = TypeVar('T', bound=TokenProtocol)  
+
+
+ParseResult = Union[
+    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
+    NamedResult['ParseResult[T]', Any], 
+    ManyResult['ParseResult[T]'],
+    OrResult['ParseResult[T]'],
+    Tuple[T, ...],
+    T,
+] 
+
+
+
+
+    
+
+
+@dataclass(frozen=True)
+class NamedRecord:
+    lens: Lens[Any, Any]
+    value: Any
+
+@dataclass(frozen=True)
+class Walker:
+    lens: Optional[Lens[Any, Any]] = None
+    def get(self, root: ParseResult[Any]) -> Dict[str, NamedRecord]:
+        match root:
+            case ManyResult(value=children):
+                new_named: Dict[str, NamedRecord] = {}
+                for i, child in enumerate(children):
+                    new_walker = replace(self, lens=(self.lens / ManyResult.lens(i)) if self.lens else ManyResult.lens(i))
+                    new_named |= new_walker.get(child)
+                return new_named
+            case OrResult(value=value):
+                new_walker = replace(self, lens=(self.lens / OrResult.lens()) if self.lens else OrResult.lens())
+                return new_walker.get(value)
+            case ThenResult(left=left, 
+                            right=right, 
+                            kind=kind):
+                new_walker = replace(self, lens=(self.lens / ThenResult.lens(kind)) if self.lens else ThenResult.lens(kind))
+                return new_walker.get(left) | new_walker.get(right)
+            case NamedResult(name=name, 
+                             value=value, 
+                             forward_map=forward_map,
+                             backward_map=backward_map,
+                             aggregator=aggregator):
+                this_lens = (self.lens / NamedResult.lens()) if self.lens else NamedResult.lens()
+                if callable(forward_map) and callable(backward_map):
+                    this_lens = this_lens.bimap(forward_map, backward_map) 
+                elif callable(forward_map):
+                    this_lens = this_lens.bimap(forward_map, lambda _: value)
+                elif callable(backward_map):
+                    raise ValueError("backward_map provided without forward_map")
+                new_walker = replace(self, lens=this_lens)
+                child_named = new_walker.get(value)
+                if aggregator is not None:
+                    return child_named | {name: NamedRecord(lens=this_lens, 
+                                                            value=aggregator(child_named))}
+                else:
+                    return child_named
+        return {}
+
+    def set(self, root: ParseResult[Any], updated_values: Dict[str, Any]) -> ParseResult[Any]:
+        named_records = self.get(root)
+        def apply_update(name: str, value: Any, root: ParseResult[Any]) -> ParseResult[Any]:
+            if name not in named_records:
+                # Skip unknown names safely
+                return root
+            record = named_records[name]
+            target_named: NamedResult[Any, Any] = record.lens.get(root)
+            assert isinstance(target_named, NamedResult)
+
+            if target_named.aggregator is not None:
+                # Break apart dataclass/dict into child fields
+                if isinstance(value, dict):
+                    child_updates = value
+                elif is_dataclass(value) and not isinstance(value, type):
+                    child_updates = asdict(value)
+                else:
+                    raise TypeError(f"Unsupported aggregator value for '{name}': {type(value)}")
+
+                # Recursively apply each child update
+                for child_name, child_value in child_updates.items():
+                    root = apply_update(child_name, child_value, root)
+                return root
+
+            else:
+                # Leaf: just replace the value
+                updated_named = replace(target_named, value=value)
+                return record.lens.set(root, updated_named)
+
+        for name, value in updated_values.items():
+            root = apply_update(name, value, root)
+
+        return root
+
+@dataclass(frozen=True)
+class AST(Generic[T]):
+    focus: ParseResult[T]
+    pruned: bool = False
+    parent: Optional[AST[T]] = None
+
+    def up(self)->Optional[AST[T]]:
+        return self.parent
+
+    def left(self) -> Optional[AST[T]]:
+        match self.focus:
+            case ThenResult(left=left, kind=kind):
+                return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
+
+    def right(self) -> Optional[AST[T]]:
+        match self.focus:
+            case ThenResult(right=right, kind=kind):
+                return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for right traversal")
+
+
+    def down(self, index: int) -> Optional[AST[T]]:
+        match self.focus:
+            case ManyResult(value=children):
+                if 0 <= index < len(children):
+                    return replace(self, focus=children[index], parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for ManyResult with {len(children)} children")
+            case OrResult(value=value):
+                if index == 0:
+                    return replace(self, focus=value, parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for OrResult")
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
+
+    def how_many(self)->int:
+        match self.focus:
+            case ManyResult(value=children):
+                return len(children)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for how_many")
+            
+    
+
+    @cached_property
+    def root(self) -> AST[T]:
+        while self.parent is not None:
+            self = self.parent  
+        return self
+    

{syncraft-0.1.10 → syncraft-0.1.12}/syncraft/dsl.py

@@ -156,7 +156,7 @@ class DSL(Generic[A, S], Insptectable):
     def sep_by(self, sep: DSL[Any, S]) -> DSL[ThenResult[A, ManyResult[ThenResult[None, A]]], S]:
         return (self + (sep >> self).many()).describe(
             name='sep_by',
-            fixity='infix',
+            fixity='prefix',
             parameter=[self, sep]
         )
     

syncraft-0.1.12/syncraft/generator.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+from typing import (
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, Hashable, 
+    cast, List
+)
+from functools import cached_property
+from dataclasses import dataclass, replace
+from syncraft.algebra import (
+    Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
+    NamedResult, OrResult, ManyResult, ThenKind
+)
+from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
+from sqlglot import TokenType
+import re
+import rstr
+from functools import lru_cache
+import random
+
+B = TypeVar('B')
+T = TypeVar('T', bound=TokenProtocol)  
+
+GenResult = Union[
+    ThenResult['GenResult[T]', 'GenResult[T]'], 
+    ManyResult['GenResult[T]'],
+    OrResult['GenResult[T]'],
+    Iterable[T],
+    T
+]
+
+@dataclass(frozen=True)
+class GenState(Generic[T], Insptectable):
+    ast: Optional[AST[T]]
+    seed: int
+
+    def fork(self, tag: Any) -> GenState[T]:
+        return replace(self, seed=hash((self.seed, tag)))
+
+    def rng(self, tag: Any = None) -> random.Random:
+        return random.Random(self.seed if tag is None else hash((self.seed, tag)))
+
+    def to_string(self, interested: Callable[[Any], bool]) -> str | None:
+        return f"GenState(current={self.focus})"
+
+    @cached_property
+    def pruned(self)->bool:
+        return self.ast is None or self.ast.pruned
+    
+
+    @property
+    def focus(self) -> Optional[ParseResult[T]]:
+        if self.ast is None:
+            return None
+        return self.ast.focus
+    
+
+    def left(self)-> GenState[T]:
+        if self.ast is None:
+            return self
+        return replace(self, ast=self.ast.left())
+
+    def right(self) -> GenState[T]:
+        if self.ast is None:
+            return self
+        return replace(self, ast=self.ast.right())
+    
+    def up(self)->GenState[T]:
+        if self.ast is None:
+            return self
+        return replace(self, ast=self.ast.up())
+    
+    def down(self, index: int) -> GenState[T]:
+        if self.ast is None:
+            return self
+        return replace(self, ast=self.ast.down(index))
+    
+    @cached_property
+    def how_many(self) -> int:
+        if self.ast is None:
+            return 0
+        return self.ast.how_many()
+
+    @classmethod
+    def from_ast(cls, ast: Optional[AST[T]], seed: int = 0) -> GenState[T]:
+        return cls(ast=ast, seed=seed)
+
+
+    @classmethod
+    def from_parse_result(cls, parse_result: Optional[ParseResult[T]], seed: int = 0) -> GenState[T]:
+        return cls.from_ast(AST(parse_result) if parse_result else None, seed)
+
+
+
+
+
+@lru_cache(maxsize=None)
+def token_type_from_string(token_type: Optional[TokenType], text: str, case_sensitive:bool)-> TokenType:
+    if not isinstance(token_type, TokenType) or token_type == TokenType.VAR:
+        for t in TokenType:
+            if t.value == text or str(t.value).lower() == text.lower():
+                return t
+        return TokenType.VAR
+    return token_type
+
+
+@dataclass(frozen=True)
+class TokenGen(TokenSpec):
+    def __str__(self) -> str:
+        tt = self.token_type.name if self.token_type else ""
+        txt = self.text if self.text else ""
+        reg = self.regex.pattern if self.regex else ""
+        return f"TokenGen({tt}, {txt}, {self.case_sensitive}, {reg})"
+        
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def gen(self) -> Token:
+        text: str
+        if self.text is not None:
+            text = self.text
+        elif self.regex is not None:
+            try:
+                text = rstr.xeger(self.regex)
+            except Exception as e:
+                # If the regex is invalid or generation fails
+                text = self.regex.pattern  # fallback to pattern string
+        elif self.token_type is not None:
+            text = str(self.token_type.value)
+        else:
+            text = "VALUE"
+
+        return Token(token_type= token_type_from_string(self.token_type,
+                                                        text, 
+                                                        self.case_sensitive), 
+                     text=text)        
+
+
+
+
+@dataclass(frozen=True)
+class Generator(Algebra[GenResult[T], GenState[T]]):  
+    def flat_map(self, f: Callable[[GenResult[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]]]:
+            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()
+                    return f(value).run(r, use_cache)
+            raise ValueError("flat_map should always return a value or an error.")
+        return Generator(run_f = flat_map_run, name=self.name) # type: ignore  
+    
+        
+
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[GenResult[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[GenResult[T]], GenState[T]]]:
+            if input.pruned:
+                upper = at_most if at_most is not None else at_least + 2
+                count = input.rng("many").randint(at_least, upper)
+                ret: List[Any] = []
+                for i in range(count):
+                    forked_input = input.down(0).fork(tag=len(ret))
+                    match self.run(forked_input, use_cache):
+                        case Right((value, next_input)):
+                            ret.append(value)
+                        case Left(_):
+                            pass
+                return Right((ManyResult(tuple(ret)), input))
+            else:
+                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((ManyResult(tuple(ret)), input))
+        return self.__class__(many_run, name=f"many({self.name})")  # type: ignore
+    
+ 
+    def or_else(self, # type: ignore
+                other: Algebra[GenResult[T], GenState[T]]
+                ) -> Algebra[OrResult[GenResult[T]], GenState[T]]: 
+        def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[OrResult[GenResult[T]], GenState[T]]]:
+            if input.pruned:
+                forked_input = input.fork(tag="or_else")
+                match forked_input.rng("or_else").choice((self, other)).run(forked_input, use_cache):
+                    case Right((value, next_input)):
+                        return Right((OrResult(value), next_input))
+                    case Left(error):
+                        return Left(error)
+            else:
+                match self.run(input.down(0), use_cache):
+                    case Right((value, next_input)):
+                        return Right((OrResult(value), next_input))
+                    case Left(error):
+                        match other.run(input.down(0), use_cache):
+                            case Right((value, next_input)):
+                                return Right((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
+
+    @classmethod
+    def token(cls, 
+              token_type: Optional[TokenType] = None, 
+              text: Optional[str] = None, 
+              case_sensitive: bool = False,
+              regex: Optional[re.Pattern[str]] = None
+              )-> Algebra[GenResult[T], GenState[T]]:      
+        gen = TokenGen(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)  
+        lazy_self: Algebra[GenResult[T], GenState[T]]
+        def token_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[GenResult[Token], GenState[T]]]:
+            if input.pruned:
+                return Right((gen.gen(), input))
+            else:
+                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((current, input))
+        lazy_self = cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})')  # type: ignore
+        return lazy_self
+
+
+
+def generate(gen: Algebra[Any, Any], data: Optional[AST[Any]] = None, seed: int = 0) -> AST[Any] | Any:
+    state = GenState.from_ast(data, seed)
+    result = gen.run(state, use_cache=False)
+    if isinstance(result, Right):
+        return AST(result.value[0])
+    assert isinstance(result, Left), "Generator must return Either[Any, Tuple[Any, Any]]"
+    return result.value
+