j-perm 0.1.3.1__py3-none-any.whl

j_perm/schema/__init__.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Mapping
+
+from ..engine import normalize_actions
+
+_JSON_TYPE = {
+    str: "string",
+    int: "integer",
+    float: "number",
+    bool: "boolean",
+    list: "array",
+    dict: "object",
+    type(None): "null",
+}
+
+
+def _split_pointer(p: str) -> List[str]:
+    return [t.replace("~1", "/").replace("~0", "~") for t in p.lstrip("/").split("/")]
+
+
+def _merge(dst: dict, patch: dict) -> None:
+    for key, val in patch.items():
+        if isinstance(dst.get(key), dict) and isinstance(val, dict):
+            _merge(dst[key], val)
+        else:
+            dst[key] = val
+
+
+def build_schema(spec: Any) -> dict:
+    """Build a JSON Schema approximation from a DSL script.
+
+    The algorithm scans all steps that write to paths, infers basic JSON types from
+    literal values and respects replace_root / foreach / $eval nesting.
+    """
+    root: Dict[str, Any] = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+
+    steps = normalize_actions(spec)
+
+    def _wild(pointer: str) -> str:
+        """Replace any ${...} template segments in pointer with '*' to avoid collisions."""
+        return re.sub(r"\$\{[^}]+}", "*", pointer)
+
+    def _ensure(pointer: str, is_append: bool) -> Dict[str, Any]:
+        """Ensure that the schema tree contains the path described by pointer."""
+        cur = root
+        for tok in _split_pointer(pointer):
+            cur.setdefault("required", [])
+            if tok not in cur["required"]:
+                cur["required"].append(tok)
+
+            cur = cur.setdefault("properties", {}).setdefault(
+                tok,
+                {"type": "object", "properties": {}},
+            )
+
+        if is_append:
+            cur["type"] = "array"
+
+        return cur
+
+    def _scan_value(val: Any) -> None:
+        if isinstance(val, Mapping):
+            if "$eval" in val:
+                nested = normalize_actions(val["$eval"])
+                _scan(nested)
+
+            for v in val.values():
+                _scan_value(v)
+
+        elif isinstance(val, (list, tuple)):
+            for item in val:
+                _scan_value(item)
+
+    def _scan(items: List[dict]) -> None:
+        for step in items:
+            op = step.get("op")
+
+            if op == "replace_root":
+                val = step.get("value")
+                if not (isinstance(val, Mapping) and "$ref" in val):
+                    root["type"] = _JSON_TYPE.get(type(val), "object")
+                _scan_value(val)
+                continue
+
+            if "do" in step and isinstance(step["do"], list):
+                _scan(step["do"])
+
+            if "path" in step:
+                path_raw = step["path"]
+                path = _wild(path_raw)
+
+                is_append = path.endswith("/-")
+                leaf = _ensure(path[:-2] if is_append else path, is_append)
+
+                if "value" in step and not isinstance(step["value"], Mapping):
+                    leaf["type"] = _JSON_TYPE.get(type(step["value"]), "object")
+
+                _scan_value(step.get("value"))
+            else:
+                _scan_value(step.get("value"))
+
+    _scan(steps)
+    return root

j_perm/utils/pointers.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Mapping, MutableMapping, List, Tuple
+
+_SLICE_RE = re.compile(r"(.+)\[(-?\d*):(-?\d*)]$")
+
+
+def _decode(tok: str) -> str:
+    """Decode a single JSON Pointer token, handling RFC6901-style escapes."""
+    return (
+        tok.replace("~0", "~")
+        .replace("~1", "/")
+        .replace("~2", "$")
+        .replace("~3", ".")
+    )
+
+
+def jptr_get(doc: Any, ptr: str) -> Any:
+    """Read value by JSON Pointer, supporting root and '..' segments."""
+    if ptr in ("", "/", "."):
+        return doc
+
+    tokens = ptr.lstrip("/").split("/")
+    cur: Any = doc
+    parents: List[Tuple[Any, Any]] = []
+
+    for raw_tok in tokens:
+        if raw_tok == "..":
+            if parents:
+                cur, _ = parents.pop()
+            else:
+                cur = doc
+            continue
+
+        key = _decode(raw_tok)
+
+        if isinstance(cur, (list, tuple)):
+            idx = int(key)
+            parents.append((cur, idx))
+            cur = cur[idx]
+        else:
+            parents.append((cur, key))
+            cur = cur[key]
+
+    return cur
+
+
+def maybe_slice(ptr: str, src: Mapping[str, Any]) -> Any:
+    """Resolve a pointer and optional Python-style slice suffix '[start:end]' for arrays."""
+    m = _SLICE_RE.match(ptr)
+    if m:
+        base, s, e = m.groups()
+        seq = jptr_get(src, base)
+        if not isinstance(seq, (list, tuple)):
+            raise TypeError(f"{base} is not a list (slice requested)")
+
+        start = int(s) if s else None
+        end = int(e) if e else None
+        return seq[start:end]
+
+    return jptr_get(src, ptr)
+
+
+def jptr_ensure_parent(
+        doc: MutableMapping[str, Any],
+        ptr: str,
+        *,
+        create: bool = False,
+):
+    """Return (container, leaf_key) for ptr, optionally creating intermediate nodes."""
+    raw_parts = ptr.lstrip("/").split("/")
+    parts: List[str] = []
+
+    for raw in raw_parts:
+        if raw == "..":
+            if parts:
+                parts.pop()
+            continue
+        parts.append(raw)
+
+    if not parts:
+        return doc, ""
+
+    cur: Any = doc
+
+    for raw in parts[:-1]:
+        token = _decode(raw)
+
+        if isinstance(cur, list):
+            idx = int(token)
+            if idx >= len(cur):
+                if create:
+                    while idx >= len(cur):
+                        cur.append({})
+                else:
+                    raise IndexError(f"{ptr}: index {idx} out of range")
+            cur = cur[idx]
+        else:
+            if token not in cur:
+                if create:
+                    cur[token] = {}
+                else:
+                    raise KeyError(f"{ptr}: missing key '{token}'")
+            cur = cur[token]
+
+    leaf = _decode(parts[-1])
+    return cur, leaf

j_perm/utils/special.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import copy
+from typing import Any, Mapping
+
+from .pointers import maybe_slice
+from .subst import substitute
+from ..engine import apply_actions
+
+_MISSING = object()
+
+
+def resolve_special(val: Any, src: Mapping[str, Any]):
+    """Resolve $ref / $eval constructs inside an arbitrary value tree."""
+    if isinstance(val, dict):
+        if "$ref" in val:
+            ptr = substitute(val["$ref"], src)
+            dflt = val.get("$default", _MISSING)
+            try:
+                return copy.deepcopy(maybe_slice(ptr, src))
+            except Exception:
+                if dflt is not _MISSING:
+                    return copy.deepcopy(dflt)
+                raise
+
+        if "$eval" in val:
+            out = apply_actions(val["$eval"], dest={}, source=src)
+            if "$select" in val:
+                sel = maybe_slice(val["$select"], out)  # type: ignore[arg-type]
+                return sel
+            return out
+
+        return {k: resolve_special(v, src) for k, v in val.items()}
+
+    if isinstance(val, list):
+        return [resolve_special(x, src) for x in val]
+
+    if isinstance(val, tuple):
+        return tuple(resolve_special(x, src) for x in val)
+
+    return val

j_perm/utils/subst.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import copy
+import json
+from typing import Any, Mapping, List
+
+import jmespath
+
+from ..jmes_ext import JP_OPTIONS
+
+_CASTERS = {
+    "int": int,
+    "float": float,
+    "str": str,
+    "bool": lambda x: bool(int(x)) if isinstance(x, (int, str)) else bool(x),
+}
+
+
+def _resolve_expr(expr: str, data: Mapping[str, Any]) -> Any:
+    """Resolve a single ${...} expression body."""
+    from .pointers import maybe_slice  # local import to avoid cycles
+
+    expr = expr.strip()
+
+    # 1) simple casters like int:/path
+    for prefix, fn in _CASTERS.items():
+        tag = f"{prefix}:"
+        if expr.startswith(tag):
+            inner = expr[len(tag):]
+            value = flat_substitute(inner, data)
+            if isinstance(value, str) and value.startswith("${") and value.endswith("}"):
+                value = flat_substitute(value, data)
+            return fn(value)
+
+    # 2) JMESPath expression ? <expr>
+    if expr.startswith("?"):
+        query_raw = expr[1:].lstrip()
+        query_expanded = flat_substitute(query_raw, data)
+        return jmespath.search(query_expanded, data, options=JP_OPTIONS)
+
+    # 3) nested template ${...}
+    if expr.startswith("${") and expr.endswith("}"):
+        return flat_substitute(expr, data)
+
+    # 4) default: treat as JSON Pointer (relative to root)
+    pointer = "/" + expr.lstrip("/")
+    try:
+        return maybe_slice(pointer, data)  # type: ignore[arg-type]
+    except Exception:
+        return None
+
+
+def flat_substitute(tmpl: str, data: Mapping[str, Any]) -> Any:
+    """One-pass interpolation that replaces all ${...} occurrences in a string."""
+    if "${" not in tmpl:
+        return tmpl
+
+    # Entire string is a single ${...}
+    if tmpl.startswith("${") and tmpl.endswith("}"):
+        body = tmpl[2:-1]
+        return copy.deepcopy(_resolve_expr(body, data))
+
+    out: List[str] = []
+    i = 0
+    while i < len(tmpl):
+        if tmpl[i:i + 2] == "${":
+            depth = 0
+            j = i + 2
+
+            while j < len(tmpl):
+                ch = tmpl[j]
+
+                if ch == "{" and tmpl[j - 1] == "$":
+                    depth += 1
+                elif ch == "}":
+                    if depth == 0:
+                        expr = tmpl[i + 2:j]
+                        val = _resolve_expr(expr, data)
+
+                        if isinstance(val, (Mapping, list)):
+                            rendered = json.dumps(val, ensure_ascii=False)
+                        else:
+                            rendered = str(val)
+
+                        out.append(rendered)
+                        i = j + 1
+                        break
+                    depth -= 1
+
+                j += 1
+            else:
+                # no closing brace found, treat '${' as a literal
+                out.append(tmpl[i])
+                i += 1
+        else:
+            out.append(tmpl[i])
+            i += 1
+
+    return "".join(out)
+
+
+def deep_substitute(obj: Any, data: Mapping[str, Any], _depth: int = 0) -> Any:
+    """Recursively apply interpolation to strings, mapping keys/values and sequences."""
+    if _depth > 50:
+        raise RecursionError("too deep interpolation")
+
+    if isinstance(obj, str):
+        out = flat_substitute(obj, data)
+        if isinstance(out, str) and "${" in out:
+            return deep_substitute(out, data, _depth + 1)
+        return out
+
+    if isinstance(obj, list):
+        return [deep_substitute(item, data, _depth) for item in obj]
+
+    if isinstance(obj, tuple):
+        return [deep_substitute(item, data, _depth) for item in obj]
+
+    if isinstance(obj, Mapping):
+        out: dict[Any, Any] = {}
+        for k, v in obj.items():
+            new_key = deep_substitute(k, data, _depth) if isinstance(k, str) else k
+            if new_key in out:
+                raise KeyError(f"duplicate key after substitution: {new_key!r}")
+            out[new_key] = deep_substitute(v, data, _depth)
+        return out
+
+    return obj
+
+
+# Public alias mirroring the original _substitute name
+substitute = deep_substitute
+substitute.__name__ = "substitute"

j_perm/utils/tuples.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+
+def tuples_to_lists(obj: Any) -> Any:
+    """Recursively convert all tuples into lists so JMESPath indexers work reliably."""
+    if isinstance(obj, tuple):
+        return [tuples_to_lists(x) for x in obj]
+
+    if isinstance(obj, list):
+        return [tuples_to_lists(x) for x in obj]
+
+    if isinstance(obj, Mapping):
+        return {k: tuples_to_lists(v) for k, v in obj.items()}
+
+    return obj