generflow-core 0.2.0__py3-none-any.whl

generflow_core/spec/parser.py

@@ -0,0 +1,332 @@
+"""GF-Lang parser with partial-stream recovery.
+
+Designed for streaming: feed lines one at a time via feed_line(), get
+back the parsed nodes that completed. Lines that don't parse cleanly
+are flagged as invalid but never crash the stream.
+"""
+from __future__ import annotations
+
+import re
+from typing import Iterator
+
+from .ast import Assignment, Component, Literal, Ref
+
+
+_IDENT = re.compile(r"[a-zA-Z_][a-zA-Z0-9_\-]*")
+_STRING_DQ = re.compile(r'"((?:[^"\\]|\\.)*)"')
+_STRING_SQ = re.compile(r"'((?:[^'\\]|\\.)*)'")
+_NUMBER = re.compile(r"-?\d+(?:\.\d+)?")
+_BOOL = re.compile(r"(true|false)\b")
+
+
+class ParseError(Exception):
+    """Raised when a complete line cannot be parsed."""
+
+
+class GFLangParser:
+    """Incremental, partial-recovery parser for GF-Lang.
+
+    Usage:
+        parser = GFLangParser()
+        for event in stream:
+            nodes = parser.feed(event.line)
+            for node in nodes:
+                render(node)
+        leftover = parser.flush()  # anything left in buffer
+    """
+
+    def __init__(self) -> None:
+        self._buf = ""
+
+    def feed_line(self, line: str) -> list[Assignment | Component]:
+        """DEPRECATED: use feed_chunk."""
+        return self.feed_chunk(line + "\n")
+
+    def feed_chunk(self, chunk: str) -> list[Assignment | Component]:
+        """Feed a raw chunk (may contain partial lines, partial expressions).
+
+        State machine:
+          - Buffer accumulates text until the parser can extract a complete
+            top-level node (a balanced `Component(...)` or `root = Component(...)`).
+          - We retry parsing the buffer in a loop; if a complete node is
+            found, it's emitted and removed from the buffer.
+          - If the buffer is mid-construct (open parens/brackets), we hold it
+            and wait for more input.
+          - If the buffer starts with non-identifier garbage, drop everything
+            up to the next newline so a bad prefix doesn't block us.
+        """
+        out: list[Assignment | Component] = []
+        self._buf += chunk
+        # safety counter to prevent infinite loops
+        max_iter = 1000
+        for _ in range(max_iter):
+            node, consumed = self._try_parse_top(self._buf)
+            if node is None:
+                break
+            self._buf = self._buf[consumed:]
+            out.append(node)
+        # partial-recovery loop: drop garbage prefixes and try again
+        for _ in range(10):
+            if not self._buf or self._is_mid_construct(self._buf):
+                break
+            before = self._buf
+            self._drop_garbage_line()
+            if self._buf == before:
+                break
+            # try parse again after drop
+            for _ in range(max_iter):
+                node, consumed = self._try_parse_top(self._buf)
+                if node is None:
+                    break
+                self._buf = self._buf[consumed:]
+                out.append(node)
+        return out
+
+    def _is_mid_construct(self, s: str) -> bool:
+        """True if the buffer has unbalanced parens/brackets (more opens than closes)."""
+        parens = s.count("(") - s.count(")")
+        brackets = s.count("[") - s.count("]")
+        return parens > 0 or brackets > 0
+
+    def _drop_garbage_line(self) -> None:
+        """If the buffer doesn't start with a valid start, drop the first line."""
+        s = self._buf.lstrip()
+        if not s:
+            return
+        # valid start: an alpha/underscore character (identifier) — could be
+        # a component, an assignment, or an Update( expression
+        if s[0].isalpha() or s[0] == "_":
+            return
+        # garbage: drop everything up to and including the first newline
+        if "\n" in self._buf:
+            self._buf = self._buf.split("\n", 1)[1]
+        else:
+            self._buf = ""
+
+    def flush(self) -> list[Assignment | Component]:
+        """Force-parse anything left in the buffer (e.g., at end of stream)."""
+        out: list[Assignment | Component] = []
+        if self._buf.strip():
+            out.extend(self.feed_line(self._buf))
+            self._buf = ""
+        return out
+
+    # --- internal parsing -------------------------------------------------
+
+    def _try_parse_top(self, src: str) -> tuple[Assignment | Component | None, int]:
+        """Try to parse one top-level node from `src`. Returns (node, chars_consumed) or (None, 0)."""
+        src = src.lstrip()
+        if not src:
+            return None, 0
+        # assignment: identifier = ...
+        m = _IDENT.match(src)
+        if not m:
+            return None, 0
+        ident = m.group(0)
+        rest_start = m.end()
+        # peek next non-space char
+        ws = re.match(r"[ \t]*", src[rest_start:])
+        rest_start += ws.end() if ws else 0
+        if rest_start < len(src) and src[rest_start] == "=":
+            # assignment
+            after_eq = rest_start + 1
+            try:
+                node, end = self._parse_node(src, after_eq)
+            except ParseError:
+                return None, 0
+            if end is None:
+                return None, 0
+            consumed = end - (m.start() if False else 0)
+            consumed = end
+            return Assignment(identifier=ident, value=node), end
+        # component
+        try:
+            node, end = self._parse_component(src, 0)
+        except ParseError:
+            return None, 0
+        if end is None:
+            return None, 0
+        return node, end
+
+    def _skip_ws(self, src: str, i: int) -> int:
+        while i < len(src) and src[i] in " \t\n":
+            i += 1
+        return i
+
+    def _parse_node(
+        self, src: str, i: int
+    ) -> tuple[Assignment | Component | Literal | Ref | None, int | None]:
+        i = self._skip_ws(src, i)
+        if i >= len(src):
+            return None, None
+        c = src[i]
+        if c == '"' or c == "'":
+            return self._parse_string(src, i)
+        if c == "-" or c.isdigit():
+            return self._parse_number(src, i)
+        if c == "[":
+            return self._parse_list(src, i)
+        if c == "$":
+            return self._parse_ref(src, i)
+        if c.isalpha() or c == "_":
+            # could be bool, component, or bare identifier (string shorthand)
+            m = _BOOL.match(src, i)
+            if m:
+                return Literal(value=(m.group(1) == "true")), m.end()
+            # peek: if followed by '=', it's a named arg's value, not a component
+            # BUT we don't know that here — we just check if the char after the
+            # ident is whitespace+')' or ',' or whitespace+ident. If so, it's
+            # actually a component. Otherwise we still treat as component (caller
+            # distinguishes). For bare ident shorthand: if the next char is
+            # NOT '(' it's a string-literal shorthand.
+            m_id = _IDENT.match(src, i)
+            if m_id:
+                after = m_id.end()
+                if after >= len(src) or src[after] != "(":
+                    # bare identifier → treat as string literal
+                    return Literal(value=m_id.group(0)), after
+            # try component
+            try:
+                node, end = self._parse_component(src, i)
+            except ParseError:
+                return None, None
+            return node, end
+        raise ParseError(f"unexpected char {c!r} at {i}")
+
+    def _parse_string(self, src: str, i: int) -> tuple[Literal, int]:
+        quote = src[i]
+        end = i + 1
+        buf = []
+        while end < len(src):
+            ch = src[end]
+            if ch == "\\" and end + 1 < len(src):
+                buf.append(src[end + 1])
+                end += 2
+                continue
+            if ch == quote:
+                return Literal(value="".join(buf)), end + 1
+            buf.append(ch)
+            end += 1
+        raise ParseError("unterminated string")
+
+    def _parse_number(self, src: str, i: int) -> tuple[Literal, int]:
+        m = _NUMBER.match(src, i)
+        if not m:
+            raise ParseError(f"bad number at {i}")
+        s = m.group(0)
+        val: float | int = float(s) if "." in s else int(s)
+        return Literal(value=val), m.end()
+
+    def _parse_list(self, src: str, i: int) -> tuple[Literal, int]:
+        assert src[i] == "["
+        items = []
+        i += 1
+        i = self._skip_ws(src, i)
+        if i < len(src) and src[i] == "]":
+            return Literal(value=[]), i + 1
+        while i < len(src):
+            i = self._skip_ws(src, i)
+            if i >= len(src):
+                raise ParseError("unterminated list")
+            if src[i] == "]":
+                return Literal(value=items), i + 1
+            node, end = self._parse_node(src, i)
+            if end is None:
+                raise ParseError("incomplete list element")
+            items.append(node)
+            i = end
+            i = self._skip_ws(src, i)
+            if i < len(src) and src[i] == ",":
+                i += 1
+            elif i < len(src) and src[i] == "]":
+                return Literal(value=items), i + 1
+        raise ParseError("unterminated list")
+
+    def _parse_ref(self, src: str, i: int) -> tuple[Ref, int]:
+        assert src[i] == "$"
+        i += 1
+        m = _IDENT.match(src, i)
+        if not m:
+            raise ParseError("bad ref")
+        return Ref(name=m.group(0)), m.end()
+
+    def _parse_component(
+        self, src: str, i: int
+    ) -> tuple[Component, int | None]:
+        m = _IDENT.match(src, i)
+        if not m:
+            raise ParseError(f"expected identifier at {i}")
+        name = m.group(0)
+        i = m.end()
+        i = self._skip_ws(src, i)
+        if i >= len(src) or src[i] != "(":
+            # bare identifier — treat as no-arg component
+            return Component(name=name, args=[], kwargs={}), i
+        i += 1
+        args: list = []
+        kwargs: dict = {}
+        positional_idx = 0
+        def _finalize(args, kwargs):
+            """Move trailing list-literal of Components into children."""
+            if args and isinstance(args[-1], Literal) and isinstance(args[-1].value, list):
+                if all(isinstance(c, Component) for c in args[-1].value):
+                    return args[:-1], kwargs, args[-1].value
+            return args, kwargs, []
+        # parse args
+        i = self._skip_ws(src, i)
+        if i < len(src) and src[i] == ")":
+            args, kwargs, children = _finalize(args, kwargs)
+            return Component(name=name, args=args, kwargs=kwargs, children=children), i + 1
+        while i < len(src):
+            i = self._skip_ws(src, i)
+            if i >= len(src):
+                return Component(name=name), None  # incomplete
+            if src[i] == ")":
+                args, kwargs, children = _finalize(args, kwargs)
+                return Component(name=name, args=args, kwargs=kwargs, children=children), i + 1
+            # check for named arg: ident =
+            save_i = i
+            m2 = _IDENT.match(src, i)
+            if m2:
+                after_ident = m2.end()
+                ws_m = re.match(r"[ \t]*", src[after_ident:])
+                peek = after_ident + (ws_m.end() if ws_m else 0)
+                if peek < len(src) and src[peek] == "=":
+                    key = m2.group(0)
+                    val, end = self._parse_node(src, peek + 1)
+                    if end is None:
+                        return Component(name=name), None
+                    kwargs[key] = val
+                    i = end
+                else:
+                    # positional
+                    val, end = self._parse_node(src, i)
+                    if end is None:
+                        return Component(name=name), None
+                    args.append(val)
+                    i = end
+            else:
+                val, end = self._parse_node(src, i)
+                if end is None:
+                    return Component(name=name), None
+                args.append(val)
+                i = end
+            i = self._skip_ws(src, i)
+            if i < len(src) and src[i] == ",":
+                i += 1
+            elif i < len(src) and src[i] == ")":
+                args, kwargs, children = _finalize(args, kwargs)
+                return Component(name=name, args=args, kwargs=kwargs, children=children), i + 1
+            else:
+                # maybe end of input — let caller retry
+                return Component(name=name), None
+        raise ParseError("unterminated component args")
+
+
+def count_tokens(spec: str) -> int:
+    """Approximate token count (whitespace-split, treating punctuation as
+    separate tokens). Good enough for benchmarking. For real numbers use
+    tiktoken in benchmarks/run.py."""
+    # split on whitespace and common punctuation
+    tokens = re.findall(r"[a-zA-Z_][a-zA-Z0-9_\-]*|[(){}\[\],]|\d+|\S", spec)
+    return len(tokens)

generflow_core/spec/update.py

@@ -0,0 +1,136 @@
+"""Surgical updates: emit `Update(path=..., value=...)` instead of full re-render.
+
+The LLM emits `Update(...)` as a top-level line. The renderer applies the
+patch to its in-memory spec tree and re-renders only the affected nodes.
+This is the multi-turn efficiency win — turn 2+ shouldn't pay the full
+spec cost just to change one number.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from .ast import Assignment, Component, Literal, Ref
+
+
+@dataclass
+class Update:
+    path: str  # e.g. "root.children[2].kwargs.value" or "header.title"
+    value: Any  # the new value (Literal, Ref, or nested Component)
+    raw_line: str = ""
+
+    def to_dict(self) -> dict:
+        v = self.value
+        if hasattr(v, "to_dict"):
+            v = v.to_dict()
+        return {"type": "update", "path": self.path, "value": v}
+
+
+# Match:  Update(path="root.children[2].kwargs.value", value=42)
+_UPDATE_RE = re.compile(
+    r'Update\s*\(\s*path\s*=\s*("[^"]+"|[A-Za-z_][\w\-.]*)\s*,\s*value\s*=\s*(.+?)\s*\)\s*$',
+    re.DOTALL,
+)
+
+
+def parse_update(line: str, parse_value) -> Update | None:
+    """Try to parse a line as an Update expression.
+
+    `parse_value` is a callable that parses an arbitrary value expression
+    (we pass our spec parser to avoid circular imports).
+    """
+    m = _UPDATE_RE.match(line.strip())
+    if not m:
+        return None
+    path = m.group(1).strip('"').strip("'")
+    raw_value = m.group(2)
+    try:
+        val = parse_value(raw_value)
+    except Exception:
+        return None
+    return Update(path=path, value=val, raw_line=line)
+
+
+def apply_update(spec_tree: Any, update: Update) -> bool:
+    """Apply an update to a spec tree (mutates in place).
+
+    `spec_tree` is a Component (root) or a dict (when stored as JSON).
+
+    Path syntax: dot-separated, with optional [index] for children.
+    Examples:
+      "kwargs.value"          → set tree.kwargs["value"]
+      "children[2]"           → tree.children[2] = value
+      "children[2].kwargs.x"  → tree.children[2].kwargs["x"]
+    """
+    parts = _tokenize_path(update.path)
+    if not parts:
+        return False
+    node = spec_tree
+    for part in parts[:-1]:
+        node = _descend(node, part)
+        if node is None:
+            return False
+    last = parts[-1]
+    val = update.value
+    if hasattr(val, "to_dict"):
+        val = val.to_dict()
+    if last["kind"] == "key":
+        if not isinstance(node, dict):
+            return False
+        node[last["name"]] = val
+    elif last["kind"] == "index":
+        if not isinstance(node, list):
+            return False
+        idx = last["index"]
+        if idx < len(node):
+            node[idx] = val
+    return True
+
+
+def _tokenize_path(path: str) -> list[dict]:
+    """Tokenize "a.b[2].c" into [{'kind':'key','name':'a'}, {'kind':'key','name':'b'}, ...]"""
+    out: list[dict] = []
+    i = 0
+    name = ""
+    while i < len(path):
+        c = path[i]
+        if c == ".":
+            if name:
+                out.append({"kind": "key", "name": name})
+                name = ""
+        elif c == "[":
+            if name:
+                out.append({"kind": "key", "name": name})
+                name = ""
+            j = path.find("]", i)
+            if j < 0:
+                return []
+            try:
+                idx = int(path[i + 1 : j])
+            except ValueError:
+                return []
+            out.append({"kind": "index", "index": idx})
+            i = j
+        else:
+            name += c
+        i += 1
+    if name:
+        out.append({"kind": "key", "name": name})
+    return out
+
+
+def _descend(node: Any, part: dict) -> Any:
+    if part["kind"] == "key":
+        if isinstance(node, dict):
+            return node.get(part["name"])
+        if hasattr(node, "kwargs") and part["name"] in node.kwargs:
+            return node.kwargs[part["name"]]
+        if hasattr(node, "__dict__") and part["name"] in node.__dict__:
+            return getattr(node, part["name"])
+    elif part["kind"] == "index":
+        if isinstance(node, list):
+            idx = part["index"]
+            if idx < len(node):
+                return node[idx]
+    return None

generflow_core-0.2.0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: generflow-core
+Version: 0.2.0
+Summary: Generflow Python runtime — streams low-token UI specs over SSE, with HITL checkpoints, live data binding, action gating, and rewind/replay.
+Author-email: Generflow <team@generflow.dev>
+License: Apache-2.0
+Project-URL: Homepage, https://generflow.dev
+Project-URL: Repository, https://github.com/generflow/generflow
+Project-URL: Documentation, https://docs.generflow.dev
+Project-URL: Issues, https://github.com/generflow/generflow/issues
+Project-URL: Changelog, https://github.com/generflow/generflow/blob/main/CHANGELOG.md
+Keywords: ai,generative-ui,llm,sse,agent,hitl,human-in-the-loop,design-system,streaming,tooling
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: pydantic>=2.5
+Requires-Dist: openai>=1.12
+Requires-Dist: anthropic>=0.18
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tiktoken>=0.5
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: httpx>=0.26; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: generflow-core[dev]; extra == "all"
+
+# generflow-core
+
+> The Python runtime for [Generflow](https://generflow.dev) — open-source generative UI.
+
+Generflow solves four problems nobody else has solved together:
+
+1. **Token-efficient UI description** — GF-Lang is a streaming-friendly DSL that uses **57.6% fewer tokens** than equivalent JSON (benchmarked, beats JSON on 10/10 widgets).
+2. **Data-grounded rendering** — components can declare `$ref`s to live data sources (REST, SQL, GraphQL, MCP). No fabricated numbers.
+3. **HITL hallucination mitigation** — every render passes through a security boundary (component allow-list), and every action is gated by HITL checks (PII scan, missing source, ambiguity, low confidence).
+4. **Cross-platform** — Web Components + React + vanilla TS renderers. Same protocol, any framework.
+
+## Install
+
+```bash
+pip install generflow-core
+```
+
+Or with all dev extras:
+
+```bash
+pip install generflow-core[dev]
+```
+
+## Quickstart (no API key)
+
+```python
+from generflow_core.adapters import EchoAdapter
+from generflow_core.spec import GFLangParser
+from generflow_core.registry import Registry
+import asyncio
+
+async def main():
+    adapter = EchoAdapter()
+    registry = Registry()
+    parser = GFLangParser()
+
+    full = ""
+    async for chunk in adapter.stream("", "build a dashboard"):
+        full += chunk
+
+    for node in parser.feed_chunk(full):
+        if registry.has(node.name):
+            print(f"  ✓ {node.name}")
+
+asyncio.run(main())
+```
+
+## Quickstart (real LLM)
+
+```bash
+export OPENAI_API_KEY=sk-...
+python -m generflow_core.api.app    # → http://localhost:7878
+```
+
+Then send a chat message:
+
+```bash
+curl -X POST http://localhost:7878/v1/stream \
+  -H "Content-Type: application/json" \
+  -d '{"message": "build a sales dashboard", "session_id": "demo"}'
+```
+
+## CLI
+
+The package ships a CLI for local-only rendering (no LLM, no API key):
+
+```bash
+generflow-render render dashboard.gf -o dashboard.html
+generflow-render validate dashboard.gf
+generflow-render diff before.gf after.gf
+generflow-render to-a2ui dashboard.gf -o dashboard.a2ui.json
+generflow-render from-a2ui incoming.a2ui.json -o spec.gf
+```
+
+## Architecture
+
+```
+┌──────────────────┐    SSE     ┌──────────────────┐
+│   LLM Adapter    │ ─────────▶ │  SSE /v1/stream  │
+│ (OpenAI/Anthro/  │            │                  │
+│  Echo)           │            │  parser (Python) │
+└──────────────────┘            │      │           │
+                                │      ▼           │
+                                │  Registry        │
+                                │  (allow-list)    │
+                                │      │           │
+                                │      ▼           │
+                                │  DataResolver    │
+                                │  (REST/SQL/GQL)  │
+                                │      │           │
+                                │      ▼           │
+                                │  HITL gates      │
+                                │  (PII/conf/etc)  │
+                                │      │           │
+                                │      ▼           │
+                                │  Action dispatch │
+                                │  (intent → HTTP) │
+                                └──────────────────┘
+                                         │
+                                         ▼
+                              SSE events: spec.line,
+                              component.mount, data.fill,
+                              hitl.request, action.request,
+                              update, stream.end
+```
+
+## Protocol
+
+Generflow's protocol is a stream of typed SSE events. See the [GF-Lang grammar](https://github.com/generflow/generflow/blob/main/docs/gf-lang.ebnf) and the [event reference](https://docs.generflow.dev/protocol).
+
+```http
+event: session.start
+data: {"session_id":"demo","adapter":"openai"}
+
+event: spec.line
+data: {"path":"line:1","component":"Card","node":{...},"valid":true}
+
+event: data.fill
+data: {"ref":"monthly_revenue","ok":true,"value":[...]}

generflow_core-0.2.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+generflow_core/__init__.py,sha256=9_wGxsl3sTZAnOO5vHaBUh6Fuv1cI4vjeiJVF8hFAEg,79
+generflow_core/cli.py,sha256=XbqsMBoYJ0-0MGZkpcTr2RPGotPBoW7XURfh296YlTY,10547
+generflow_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+generflow_core/actions/__init__.py,sha256=mGy1yad7jxhCWxw01jOntgx77SO95PXMDvkU0eK4cWw,401
+generflow_core/actions/dispatcher.py,sha256=O5wA_Ex45r5EZawZNyJuipCtnj1UFfAyPhpRrY7PZC8,7102
+generflow_core/adapters/__init__.py,sha256=Q6xYvblGccMLT3o-YZ3m6onGYh0AMCf7S4o9dJtFAO0,312
+generflow_core/adapters/llm.py,sha256=J9N6MLvNJWzOg3khrMGi_FQenfVWmg1KPfihcOoB3BE,5665
+generflow_core/api/__init__.py,sha256=gS04y9nwp8fHbgV4ZXPly8ULHXDhyZ_-nSMwLeM_H4Q,170
+generflow_core/api/app.py,sha256=oSYwWPNZ1Cq6eQpgGUHpnx8Nww-6e1AEH2KlzADvIjo,18662
+generflow_core/api/prompt.py,sha256=rkgsqkrA1FGYlkGFkptXtg46P8AUSRm44K97WVef7Q4,2900
+generflow_core/databind/__init__.py,sha256=DiSEDrLggOrdK8i9oaChFOdykrrvowjj82EOZ_e0lso,577
+generflow_core/databind/config.py,sha256=ME-1aIFD-WEWFJhqX08WFAQmmDZazHTGzM60QY07fJY,6546
+generflow_core/databind/resolver.py,sha256=WElpGRKCxk6iRIcEXIM0au24PvHhAtJ0N2JeNj1vLI0,11635
+generflow_core/hitl/__init__.py,sha256=M5YJOtyFOjFmFAEJhbOPzWuJzI2kNOu6iN_ncdBP4zg,418
+generflow_core/hitl/gates.py,sha256=TTqi6pbhFdzF7t5WBLcYc-8b-fLvC9xBvjk6c-Hkd4M,6119
+generflow_core/interop/__init__.py,sha256=rE-DV3pnpX5aX8tyDcDMhlMX_ME1spZ7K9lcEyJhRmk,8773
+generflow_core/observability/__init__.py,sha256=BEKiFiWW3G3Qh87T2WFdL0rgLBQqXifHaJ49vDNK0vA,8145
+generflow_core/registry/__init__.py,sha256=1bNFobFtUwkVfRiMnBWZbdEOLHGu17R9bymSIt8963M,253
+generflow_core/registry/registry.py,sha256=LhFAVHUZfT4BldSbnve0jrGWVlFlSW3WuumjqPZQPas,8891
+generflow_core/replay/__init__.py,sha256=6NiTo6j4I9BG466rrWvNlBTJCbo4x2oas7NyQeg55CQ,6724
+generflow_core/spec/__init__.py,sha256=oJtqqgkL_tr6INxZ39HJQ1QClRDe9sBQ2vxeRY6X-x0,510
+generflow_core/spec/ast.py,sha256=GcQGMVDwZoZNh24APmF9wge6BtjOtDySV3OjsXKb5wY,1493
+generflow_core/spec/diff.py,sha256=amfAvP1kYKYV4Ol4xXjPKGDgoYqlnyt0E-KGCnF9ubw,6823
+generflow_core/spec/parser.py,sha256=Y6Qc08m0uayciO9UxVmsipN4lacZj10HBqSOPocYw6c,12811
+generflow_core/spec/update.py,sha256=XM-tJMPYEvaGij-Up8P9I4YDkwUrlnGr5Z4I9tkckVw,4181
+generflow_core-0.2.0.dist-info/METADATA,sha256=B-rCYy4UZruDx3dVWcvl4603_79h_yryJPjOOHY3Ows,6199
+generflow_core-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+generflow_core-0.2.0.dist-info/entry_points.txt,sha256=we2c_hJ4DOq3jFZxfkXRXijx3fLU-zKrcD6N7GgFgWI,101
+generflow_core-0.2.0.dist-info/top_level.txt,sha256=BD7V2_uvP1hK4AG78t58JF6-ignzxGYIasrHIfG-m64,15
+generflow_core-0.2.0.dist-info/RECORD,,

generflow_core-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

generflow_core-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+generflow = generflow_core.api.app:main
+generflow-render = generflow_core.cli:main

generflow_core-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+generflow_core