metaobjects 0.9.0__py3-none-any.whl

metaobjects/render/extract/json_forgiving_reader.py

@@ -0,0 +1,203 @@
+"""Stage-4 tolerant JSON reader for the bounded corpus malformation set. Never throws.
+
+Carries the FR-010 fixed-behavior edge cases:
+
+- No-hang: ``{"xs":[}`` / ``{"xs":[1,`` terminate (no infinite loop).
+- TRUNCATED sentinel: a present-but-cut-off/empty value is recorded as ``TRUNCATED``
+  so the extract stage classifies it as MALFORMED (not LOST_REQUIRED).
+"""
+from __future__ import annotations
+
+from typing import Final
+
+# Sentinel: a key appeared in the text but its value was empty/cut-off (present-but-garbled).
+TRUNCATED: Final = object()
+
+# Sentinel: the JSON ``null`` literal. Distinct from a Python ``None`` return (which this reader
+# uses internally for "no token / garbled") and from the 4-char string ``"null"``. The extract
+# phase maps this to an actual null field value (JSON null -> None), instead of letting the bare
+# ``null`` literal leak through as the text ``"null"``.
+NULL_LITERAL: Final = object()
+
+# Max container nesting before the reader stops recursing. Python's recursion limit is far
+# lower than the JVM/.NET stack, so a pathologically deep input (hundreds of nested brackets
+# in adversarial LLM output) would raise RecursionError — violating the never-throws contract.
+# Past this depth the container is skipped (string-aware, non-recursive) and recorded as
+# garbled. Far above any realistic payload nesting.
+_MAX_DEPTH: Final = 100
+
+
+class JsonForgivingReader:
+    def __init__(self) -> None:
+        self._s: str = ""
+        self._i: int = 0
+        self._depth: int = 0
+
+    def read(self, span: str | None) -> dict[str, object]:
+        """Parse ``span`` as a forgiving JSON object; empty dict for garbage/non-object root."""
+        self._s = span if span is not None else ""
+        self._i = 0
+        self._depth = 0
+        self._ws()
+        if self._i >= len(self._s) or self._s[self._i] != "{":
+            return {}
+        o = self._read_value()
+        return o if isinstance(o, dict) else {}
+
+    def _read_value(self) -> object | None:
+        self._ws()
+        if self._i >= len(self._s):
+            return None
+        c = self._s[self._i]
+        if c == "{" or c == "[":
+            if self._depth >= _MAX_DEPTH:
+                self._skip_balanced()  # too deep: consume it, record as garbled (→ MALFORMED)
+                return None
+            self._depth += 1
+            try:
+                return self._read_object() if c == "{" else self._read_array()
+            finally:
+                self._depth -= 1
+        if c in ('"', "'"):
+            return self._read_string(c)
+        return self._read_bare_scalar()
+
+    def _skip_balanced(self) -> None:
+        """Consume a balanced ``{...}``/``[...]`` (or to EOF) without recursing, string-aware."""
+        depth = 0
+        n = len(self._s)
+        while self._i < n:
+            ch = self._s[self._i]
+            if ch in ('"', "'"):
+                self._read_string(ch)  # advances past the quoted string (handles escapes)
+                continue
+            self._i += 1
+            if ch == "{" or ch == "[":
+                depth += 1
+            elif ch == "}" or ch == "]":
+                depth -= 1
+                if depth <= 0:
+                    return
+
+    def _read_object(self) -> dict[str, object]:
+        m: dict[str, object] = {}
+        self._i += 1  # consume '{'
+        while True:
+            self._ws()
+            if self._i >= len(self._s):
+                return m  # truncation
+            if self._s[self._i] == "}":
+                self._i += 1
+                return m
+            key = self._read_key()
+            if key is None:
+                return m  # truncation mid-key
+            self._ws()
+            if self._i >= len(self._s) or self._s[self._i] != ":":
+                return m  # truncation before value
+            self._i += 1  # consume ':'
+            self._ws()
+            if self._i >= len(self._s):
+                m[key] = TRUNCATED  # value cut off at EOF → present-but-garbled
+                return m
+            v = self._read_value()
+            if v is None:
+                # present key, empty/zero-width value → present-but-garbled
+                m[key] = TRUNCATED
+                self._ws()
+                if self._i < len(self._s) and self._s[self._i] == ",":
+                    self._i += 1
+                    continue
+                if self._i < len(self._s) and self._s[self._i] == "}":
+                    self._i += 1
+                return m
+            m[key] = v
+            self._ws()
+            if self._i < len(self._s) and self._s[self._i] == ",":
+                self._i += 1  # optional/trailing comma
+
+    def _read_array(self) -> list[object]:
+        xs: list[object] = []
+        self._i += 1  # consume '['
+        while True:
+            self._ws()
+            if self._i >= len(self._s):
+                return xs
+            if self._s[self._i] == "]":
+                self._i += 1
+                return xs
+            if self._s[self._i] == "}":
+                self._i += 1
+                return xs  # malformed brace-close terminates array
+            v = self._read_value()
+            if v is None:
+                # zero-width / no value → stop (no spin)
+                self._ws()
+                if self._i < len(self._s) and self._s[self._i] in ("]", "}"):
+                    self._i += 1
+                return xs
+            xs.append(v)
+            self._ws()
+            if self._i < len(self._s) and self._s[self._i] == ",":
+                self._i += 1
+            elif self._i < len(self._s) and self._s[self._i] == "]":
+                self._i += 1
+                return xs
+            else:
+                # EOF or any other non-separator char → stop
+                return xs
+
+    def _read_key(self) -> str | None:
+        self._ws()
+        if self._i >= len(self._s):
+            return None
+        c = self._s[self._i]
+        if c in ('"', "'"):
+            return self._read_string(c)
+        start = self._i
+        while self._i < len(self._s) and (self._s[self._i].isalnum() or self._s[self._i] == "_"):
+            self._i += 1
+        return self._s[start : self._i] if self._i > start else None
+
+    def _read_string(self, quote: str) -> str:
+        self._i += 1  # opening quote
+        out: list[str] = []
+        esc = False
+        while self._i < len(self._s):
+            c = self._s[self._i]
+            self._i += 1
+            if esc:
+                out.append(_unescape(c))
+                esc = False
+            elif c == "\\":
+                esc = True
+            elif c == quote:
+                return "".join(out)
+            else:
+                out.append(c)
+        return "".join(out)  # unterminated string → return what we have
+
+    def _read_bare_scalar(self) -> object | None:
+        start = self._i
+        while self._i < len(self._s) and self._s[self._i] not in ",}]":
+            self._i += 1
+        result = self._s[start : self._i].strip()
+        if not result:
+            return None  # no token read (zero-width)
+        if result == "null":
+            return NULL_LITERAL  # JSON null literal -> explicit null, NOT the string "null"
+        return result
+
+    def _ws(self) -> None:
+        while self._i < len(self._s) and self._s[self._i].isspace():
+            self._i += 1
+
+
+def _unescape(c: str) -> str:
+    if c == "n":
+        return "\n"
+    if c == "t":
+        return "\t"
+    if c == "r":
+        return "\r"
+    return c

metaobjects/render/extract/locate.py

@@ -0,0 +1,65 @@
+"""Stages 2-3: isolate and select the payload root span.
+
+Selection rule: first-closed-else-first-open.
+"""
+from __future__ import annotations
+
+import re
+
+
+def json(text: str | None) -> str | None:
+    """First balanced ``{...}``; if none closes, first ``{`` to end; ``None`` if no ``{``."""
+    if text is None:
+        return None
+    first_open = -1
+    for i, ch in enumerate(text):
+        if ch == "{":
+            if first_open < 0:
+                first_open = i
+            end = _scan_balanced(text, i)
+            if end >= 0:
+                return text[i : end + 1]
+    return None if first_open < 0 else text[first_open:]
+
+
+def _scan_balanced(s: str, open_idx: int) -> int:
+    """Return index of the matching ``}``, or -1 if unterminated. String-aware."""
+    depth = 0
+    in_str = False
+    esc = False
+    for i in range(open_idx, len(s)):
+        c = s[i]
+        if in_str:
+            if esc:
+                esc = False
+            elif c == "\\":
+                esc = True
+            elif c == '"':
+                in_str = False
+            continue
+        if c == '"':
+            in_str = True
+        elif c == "{":
+            depth += 1
+        elif c == "}":
+            depth -= 1
+            if depth == 0:
+                return i
+    return -1
+
+
+def xml(text: str | None, root_name: str | None, case_insensitive: bool) -> str | None:
+    """Span of ``<root>...</root>``; if close absent, opener to end; ``None`` if no opener."""
+    if text is None or root_name is None:
+        return None
+    flags = re.IGNORECASE if case_insensitive else 0
+    open_re = re.compile("<" + re.escape(root_name) + r"(\s[^>]*)?>", flags)
+    open_m = open_re.search(text)
+    if open_m is None:
+        return None
+    start = open_m.start()
+    close_re = re.compile("</" + re.escape(root_name) + r"\s*>", flags)
+    close_m = close_re.search(text, open_m.end())
+    if close_m is not None:
+        return text[start : close_m.end()]
+    return text[start:]

metaobjects/render/extract/normalize.py

@@ -0,0 +1,96 @@
+"""FR-011: enum-variant normalization for the Coerce stage.
+
+ASCII-only by design: enum members are ASCII identifiers, so a pure ``[A-Za-z0-9]``
+transform is byte-identical across ports and sidesteps locale case-folding
+(Turkish-I). The mode comes from the ``@normalize`` attr (``none|collapse|strip``;
+default ``strip``). Mirrors the TS ``normalizeEnum``, the C# ``Normalize.Enum``, and
+the Java ``Normalize.enumValue``.
+
+**Uppercasing is a MANUAL a-z -> A-Z fold**, NOT :py:meth:`str.upper` (which is
+Unicode-aware and would diverge on non-ASCII). Only the 26 ASCII lowercase letters
+are folded; every other code point passes through unchanged.
+"""
+from __future__ import annotations
+
+from typing import Final
+
+# FR-011 @normalize modes — the closed cross-port vocabulary.
+NONE: Final = "none"  # exact match only (no normalization)
+COLLAPSE: Final = "collapse"  # ASCII-upper + trim + collapse runs of [\s_-]+ to "_"
+STRIP: Final = "strip"  # ASCII-upper + keep only [A-Z0-9]
+DEFAULT: Final = STRIP  # default when absent on both field and owning object
+
+# The separator set for COLLAPSE: the JS `\s` whitespace class PLUS `_` and `-`.
+# The corpus only exercises ASCII space, but the full set keeps byte-identical
+# cross-port parity with the Java/C#/TS ports' isSeparator.
+_SEPARATORS: Final = frozenset(
+    {
+        "_",
+        "-",
+        " ",  # space
+        "\t",  # tab
+        "\n",  # line feed
+        "\v",  # vertical tab (U+000B)
+        "\f",  # form feed
+        "\r",  # carriage return
+        " ",  # no-break space
+        " ",  # ogham space mark
+        "
",  # line separator
+        "
",  # paragraph separator
+        " ",  # narrow no-break space
+        " ",  # medium mathematical space
+        "　",  # ideographic space
+        "",  # zero-width no-break space (BOM)
+    }
+    # U+2000..U+200A (en/em/thin spaces etc.) — the rest of the JS \s range.
+    | {chr(c) for c in range(0x2000, 0x200B)}
+)
+
+
+def normalize_enum(s: str, mode: str) -> str:
+    """ASCII-only enum normalization. Pure ``[A-Za-z0-9]`` transform → byte-identical cross-port.
+
+    * ``none`` — identity.
+    * ``collapse`` — ASCII-upper + trim + collapse runs of ``[\\s_-]+`` to a single ``_``.
+    * ``strip`` — ASCII-upper + keep only ``[A-Z0-9]``.
+
+    Any unknown mode is treated as ``strip`` (the default), matching the cross-port resolver.
+    """
+    if mode == NONE:
+        return s
+    up = _ascii_upper(s.strip())
+    return _collapse_separators(up) if mode == COLLAPSE else _strip_non_alnum(up)
+
+
+def _ascii_upper(s: str) -> str:
+    """ASCII-only uppercasing (a-z -> A-Z); all other code points pass through unchanged."""
+    out: list[str] = []
+    for ch in s:
+        c = ord(ch)
+        out.append(chr(c - 32) if 0x61 <= c <= 0x7A else ch)
+    return "".join(out)
+
+
+def _collapse_separators(s: str) -> str:
+    """Collapse runs of whitespace / underscore / hyphen into a single ``_`` (mirrors ``/[\\s_-]+/g -> "_"``)."""
+    out: list[str] = []
+    in_run = False
+    for ch in s:
+        if ch in _SEPARATORS:
+            if not in_run:
+                out.append("_")
+                in_run = True
+        else:
+            out.append(ch)
+            in_run = False
+    return "".join(out)
+
+
+def _strip_non_alnum(s: str) -> str:
+    """Keep only ``[A-Z0-9]`` (mirrors ``/[^A-Z0-9]/g -> ""`` on an already-uppercased string)."""
+    out: list[str] = []
+    for ch in s:
+        c = ord(ch)
+        if (0x41 <= c <= 0x5A) or (0x30 <= c <= 0x39):
+            out.append(ch)
+    return "".join(out)

metaobjects/render/extract/strip.py

@@ -0,0 +1,20 @@
+"""Stage 1: remove markdown code-fence markers.
+
+Prose around the payload is left for ``locate`` to handle.
+"""
+from __future__ import annotations
+
+import re
+
+# Captures the body inside a fenced block; optional language tag (json/xml/etc) is dropped.
+_FENCE = re.compile(r"```[a-zA-Z0-9_-]*[ \t]*\r?\n(.*?)\r?\n?```", re.DOTALL)
+
+
+def strip(raw: str | None) -> str:
+    """Strip the first markdown code fence, splicing its body back in place; else trim."""
+    if raw is None:
+        return ""
+    m = _FENCE.search(raw)
+    if m:
+        return (raw[: m.start()] + m.group(1) + raw[m.end():]).strip()
+    return raw.strip()