pyfect-dev 0.1.0__py3-none-any.whl

pyfect/schema/_to_codec_go_json.py

@@ -0,0 +1,174 @@
+"""``to_codec_go_json``: JSON as Go's ``encoding/json`` writes it, where a nil slice or map is
+``null`` and a nil pointer ``null`` (Effect's ``Schema.toCodecGoJson``).
+
+``null`` decodes as an empty ``Array`` or ``Record``, or as a missing optional key; the canonical
+member stays first, so a value the schema itself accepts is read as before. Tuples, non-empty
+arrays and structs go on refusing ``null``, and nothing encodes to it."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import replace
+from typing import Any
+
+from pyfect._json_value import JsonValue
+from pyfect.schema import ast
+from pyfect.schema import getter as G
+from pyfect.schema._codec_derivation import CodecDerivation
+from pyfect.schema._codec_links import UNKNOWN_TO_JSON
+from pyfect.schema._parse import is_
+from pyfect.schema._schema import Bottom, Codec
+from pyfect.schema._to_codec_json import to_codec_json_asts
+from pyfect.schema.transformation import Transformation
+
+
+def to_codec_go_json[T, E, RD, RE](schema: Codec[T, E, RD, RE], /) -> Bottom[T, JsonValue, RD, RE]:
+    """``schema`` reading JSON a Go program wrote. A declaration with no codec is read as JSON."""
+    canonical = to_codec_json_asts([schema.__codec__().ast])[0]
+    return Bottom(_on_last(_nil_as_empty)(_GoNil()(canonical)))
+
+
+def _on_last(f: Callable[[ast.AST], ast.AST]) -> Callable[[ast.AST], ast.AST]:
+    """``f`` on ``node``, or on what the last link of its encoding reads."""
+
+    def apply(node: ast.AST) -> ast.AST:
+        if node.encoding is None:
+            return f(node)
+        *init, last = node.encoding
+        to = apply(last.to)
+        return (
+            node
+            if to is last.to
+            else replace(node, encoding=(*init, ast.Link(to, last.transformation)))
+        )
+
+    return apply
+
+
+def _forbidden(_: object) -> str:
+    return "Go nil values are never encoded"
+
+
+def _null_to(decode: G.Getter[Any, Any]) -> Transformation[Any, Any]:
+    return Transformation(decode, G.forbidden(_forbidden))
+
+
+_NULL_AS_MISSING = _null_to(G.transform_optional(lambda _: None))
+_NULL_AS_EMPTY_ARRAY = _null_to(G.transform(lambda _: []))
+_NULL_AS_EMPTY_RECORD = _null_to(G.transform(lambda _: {}))
+_EMPTY_ARRAY = ast.Arrays((), ())
+_EMPTY_RECORD = ast.record(ast.string, ast.never)
+
+
+def _is_go_nil(node: ast.AST) -> bool:
+    """A union this codec built, so applying it again changes nothing."""
+    if not isinstance(node, ast.Union):
+        return False
+    encoding = node.types[-1].encoding
+    return encoding is not None and encoding[0].transformation in (
+        _NULL_AS_MISSING,
+        _NULL_AS_EMPTY_ARRAY,
+        _NULL_AS_EMPTY_RECORD,
+    )
+
+
+def _last_encoding(node: ast.AST) -> ast.AST:
+    return node if node.encoding is None else _last_encoding(node.encoding[-1].to)
+
+
+def _accepts_null(node: ast.AST) -> bool:
+    """Whether the schema certainly takes ``None`` (a ``Suspend`` stays unresolved, so a recursive
+    definition stays lazy): skips the member added for it."""
+    encoded = _last_encoding(node)
+    match encoded:
+        case ast.Union():
+            return encoded.checks is None and any(map(_accepts_null, encoded.types))
+        case ast.Null() | ast.Unknown() | ast.Any() | ast.Declaration():
+            bare: Bottom[object] = Bottom(ast.replace_context(encoded, optional_key=False))
+            return is_(bare)(None)
+        case _:
+            return False
+
+
+def _or_null(node: ast.AST, member: ast.AST) -> ast.AST:
+    bare = ast.replace_context(node, optional_key=False) if node.optional_key else node
+    union = ast.Union((bare, member))
+    if node.optional_key or node.key_annotations:
+        return ast.replace_context(
+            union, key_annotations=node.key_annotations, optional_key=node.optional_key
+        )
+    return union
+
+
+def _nil_as_empty(node: ast.AST) -> ast.AST:
+    match node:
+        case ast.Suspend():
+            return replace(node, thunk=lambda: _on_last(_nil_as_empty)(node.target))
+        case ast.Arrays(elements=(), rest=(_,)):
+            to = ast.decode_to(
+                ast.null, replace(_EMPTY_ARRAY, checks=node.checks), _NULL_AS_EMPTY_ARRAY
+            )
+            return _or_null(node, to)
+        case ast.Objects(properties=(), index_signatures=(_, *_)):
+            to = ast.decode_to(
+                ast.null, replace(_EMPTY_RECORD, checks=node.checks), _NULL_AS_EMPTY_RECORD
+            )
+            return _or_null(node, to)
+        case _:
+            return node
+
+
+def _nil_as_missing(node: ast.AST) -> ast.AST:
+    match node:
+        case ast.Suspend():
+            return replace(node, thunk=lambda: _on_last(_nil_as_missing)(node.target))
+        case _ if _is_go_nil(node) or _accepts_null(node):
+            return node
+        case _:
+            return _or_null(node, ast.decode_to(ast.null, ast.never, _NULL_AS_MISSING))
+
+
+def _nil_for_key(node: ast.AST) -> ast.AST:
+    return _nil_as_missing(node) if node.optional_key else _nil_as_empty(node)
+
+
+class _GoNil(CodecDerivation):
+    opaque = UNKNOWN_TO_JSON
+
+    def _leaf(self, node: ast.AST) -> ast.AST:
+        return node
+
+    def _priority(self, encoded: ast.AST) -> int:
+        return 0
+
+    def _union(self, node: ast.Union) -> ast.Union:
+        return node if _is_go_nil(node) else super()._union(node)
+
+    def _step(self, node: ast.AST) -> ast.AST:
+        if isinstance(node, ast.Arrays):
+            elements = tuple(
+                replace(e, type=_on_last(_nil_as_empty)(self(e.type))) for e in node.elements
+            )
+            rest = tuple(_on_last(_nil_as_empty)(self(t)) for t in node.rest)
+            same = all(
+                a.type is b.type for a, b in zip(elements, node.elements, strict=True)
+            ) and all(a is b for a, b in zip(rest, node.rest, strict=True))
+            return node if same else replace(node, elements=elements, rest=rest)
+        return super()._step(node)
+
+    def _objects(self, node: ast.Objects) -> ast.Objects:
+        properties = tuple(
+            replace(
+                p,
+                type=_on_last(_nil_as_missing if p.optional_when_encoded() else _nil_for_key)(
+                    self(p.type)
+                ),
+            )
+            for p in node.properties
+        )
+        for_key = _on_last(_nil_for_key)
+        indexes = tuple(replace(i, type=for_key(self(i.type))) for i in node.index_signatures)
+        same = all(
+            a.type is b.type for a, b in zip(properties, node.properties, strict=True)
+        ) and all(a.type is b.type for a, b in zip(indexes, node.index_signatures, strict=True))
+        return node if same else replace(node, properties=properties, index_signatures=indexes)

pyfect/schema/_to_codec_json.py

@@ -0,0 +1,73 @@
+"""``to_codec_json``: a schema's canonical JSON codec (Effect's
+``Schema.toCodecJson``).
+
+The derived schema decodes the same values from JSON: each node whose
+values are not JSON gets an encoding from one that is, at the end of its
+existing encoding chain. A number that may be non-finite is written as
+``"NaN"`` / ``"Infinity"`` / ``"-Infinity"``, a bigint as its digits, an
+``Unknown`` value as JSON, a declaration through its ``to_codec_json`` /
+``to_codec`` annotation (``Option`` as ``{"_tag": "Some", "value": ...}``,
+...) or as JSON when it has none, a mapping's ``int`` keys as text. The
+other nodes are rebuilt from their derived parts; ``Any`` is kept as it is.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from dataclasses import replace
+from typing import cast
+
+from pyfect._json_value import JsonValue
+from pyfect.schema import ast
+from pyfect.schema._codec_derivation import CodecDerivation
+from pyfect.schema._codec_links import (
+    BIG_INT_TO_STRING,
+    NUMBER_TO_JSON,
+    UNKNOWN_TO_JSON,
+    is_finite_number,
+)
+from pyfect.schema._schema import Bottom, Codec
+
+
+def to_codec_json[T, E, RD, RE](schema: Codec[T, E, RD, RE], /) -> Bottom[T, JsonValue, RD, RE]:
+    """``schema`` decoding its values from JSON (Effect's ``toCodecJson``)."""
+    return Bottom(_Derivation()(schema.__codec__().ast))
+
+
+def to_codec_json_asts(nodes: Sequence[ast.AST]) -> list[ast.AST]:
+    """The JSON forms of ``nodes`` from one derivation, so a node given
+    twice (or shared between them) has one derived node, as Effect's
+    memoized derivation gives."""
+    derive = _Derivation()
+    return [derive(node) for node in nodes]
+
+
+class _Derivation(CodecDerivation):
+    opaque = UNKNOWN_TO_JSON
+
+    def _leaf(self, node: ast.AST) -> ast.AST:
+        match node:
+            case ast.Declaration():
+                return self._declaration(node)
+            case ast.Unknown():
+                return replace(node, encoding=(UNKNOWN_TO_JSON,))
+            case ast.Number():
+                return node if is_finite_number(node) else replace(node, encoding=(NUMBER_TO_JSON,))
+            case ast.BigInt():
+                return replace(node, encoding=(BIG_INT_TO_STRING,))
+            case _:
+                return node
+
+    def _priority(self, encoded: ast.AST) -> int:
+        return 0 if isinstance(encoded, ast.BigInt) else 1
+
+    def _declaration(self, node: ast.Declaration) -> ast.AST:
+        annotations = node.annotations or {}
+        get_link = annotations.get("to_codec_json") or annotations.get("to_codec")
+        if not callable(get_link):
+            return replace(node, encoding=(UNKNOWN_TO_JSON,))
+        make = cast("Callable[[tuple[ast.AST, ...]], ast.Link | None]", get_link)
+        link = make(tuple(ast.to_encoded(p) for p in node.type_parameters))
+        if link is None:
+            return node
+        return replace(node, encoding=(ast.Link(self(link.to), link.transformation),))

pyfect/schema/_to_codec_string_tree.py

@@ -0,0 +1,115 @@
+"""``to_codec_string_tree``: a schema's canonical string-tree codec (Effect's
+``Schema.toCodecStringTree``).
+
+The derived schema decodes the same values from a tree of strings: mappings
+and sequences stay, and every leaf is text. ``None`` is ``"null"``, a
+boolean ``"true"`` / ``"false"``, a number or bigint its digits, a
+non-string literal or enum value its text, and a declaration goes through
+its ``to_codec_string_tree`` annotation, else its ``to_codec_json`` /
+``to_codec`` one (an error when it has none). ``Unknown`` values are kept
+as any string tree; ``Any`` is kept as it is.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import replace
+from typing import cast
+
+from pyfect.schema import ast
+from pyfect.schema._codec_derivation import CodecDerivation
+from pyfect.schema._codec_links import (
+    BIG_INT_TO_STRING,
+    BOOLEAN_TO_STRING,
+    FINITE_TO_STRING,
+    NULL_TO_STRING,
+    NUMBER_TO_STRING,
+    UNKNOWN_TO_STRING_TREE,
+    enum_to_string,
+    is_finite_number,
+    literal_to_string,
+)
+from pyfect.schema._schema import Bottom, Codec
+from pyfect.schema._to_codec_array_from_single import FROM_SINGLE
+
+type StringTree = str | Sequence[StringTree] | Mapping[str, StringTree] | None
+"""Text leaves (``None`` for Effect's ``undefined``) in lists and string-keyed
+mappings (Effect's ``StringTree``)."""
+
+
+def to_codec_string_tree[T, E, RD, RE](
+    schema: Codec[T, E, RD, RE], /
+) -> Bottom[T, StringTree, RD, RE]:
+    """``schema`` decoding its values from a string tree (Effect's
+    ``toCodecStringTree``). A declaration with no codec annotation is a
+    ``ValueError``."""
+    return Bottom(to_codec_string_tree_ast(schema.__codec__().ast))
+
+
+def to_codec_string_tree_ast(node: ast.AST) -> ast.AST:
+    return _Derivation()(node)
+
+
+class _Derivation(CodecDerivation):
+    opaque = UNKNOWN_TO_STRING_TREE
+
+    def _stops_at(self, link: ast.Link) -> bool:
+        return link.transformation is FROM_SINGLE
+
+    def _leaf(self, node: ast.AST) -> ast.AST:  # noqa: PLR0911
+        match node:
+            case ast.Declaration():
+                return self._declaration(node)
+            case ast.Null():
+                return replace(node, encoding=(NULL_TO_STRING,))
+            case ast.Boolean():
+                return replace(node, encoding=(BOOLEAN_TO_STRING,))
+            case ast.Unknown():
+                return replace(node, encoding=(UNKNOWN_TO_STRING_TREE,))
+            case ast.Number():
+                link = FINITE_TO_STRING if is_finite_number(node) else NUMBER_TO_STRING
+                return replace(node, encoding=(link,))
+            case ast.BigInt():
+                return replace(node, encoding=(BIG_INT_TO_STRING,))
+            case ast.Literal() if not isinstance(node.literal, str):
+                return literal_to_string(node)
+            case ast.Enum():
+                return self._enum(node)
+            case _:
+                return node
+
+    def _enum(self, node: ast.Enum) -> ast.AST:
+        match node.side:
+            case "encode":
+                return replace(node, encoding=(UNKNOWN_TO_STRING_TREE,))
+            case "type":
+                return self._enum(replace(node, side="decode"))
+            case "decode" | "encoded":
+                if all(isinstance(member.value, str) for member in node.enum):
+                    return node
+                return enum_to_string(node)
+
+    def _priority(self, encoded: ast.AST) -> int:
+        return 0 if isinstance(encoded, ast.Null | ast.Boolean | ast.Number | ast.BigInt) else 1
+
+    def _declaration(self, node: ast.Declaration) -> ast.AST:
+        annotations = node.annotations or {}
+        parameters = tuple(ast.to_encoded(p) for p in node.type_parameters)
+        own = annotations.get("to_codec_string_tree")
+        if callable(own):
+            link = _link_of(own, parameters)
+            return node if link is None else self._linked(node, link)
+        for key in ("to_codec_json", "to_codec"):
+            get_link = annotations.get(key)
+            if callable(get_link):
+                link = _link_of(get_link, parameters)
+                if link is not None:
+                    return self._linked(node, link)
+        raise ValueError(f"Missing structural codec for StringTree: {node.expected()}")
+
+    def _linked(self, node: ast.Declaration, link: ast.Link) -> ast.AST:
+        return replace(node, encoding=(ast.Link(self(link.to), link.transformation),))
+
+
+def _link_of(get_link: object, parameters: tuple[ast.AST, ...]) -> ast.Link | None:
+    return cast("Callable[[tuple[ast.AST, ...]], ast.Link | None]", get_link)(parameters)

pyfect/schema/_to_differ_json_patch.py

@@ -0,0 +1,44 @@
+"""``to_differ_json_patch``: diff and patch a schema's values as JSON Patch over their JSON form
+(Effect's ``Schema.toDifferJsonPatch``)."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from pyfect import json_patch
+from pyfect.json_patch import JsonPatch
+from pyfect.schema._parse import decode_sync, encode_sync
+from pyfect.schema._schema import Codec
+from pyfect.schema._to_codec_json import to_codec_json
+
+
+@dataclass(frozen=True, slots=True)
+class Differ[V, P]:
+    """Effect's ``Differ``: how values of ``V`` differ, as patches of type ``P``."""
+
+    empty: P
+    diff: Callable[[V, V], P]
+    combine: Callable[[P, P], P]
+    patch: Callable[[V, P], V]
+
+
+def to_differ_json_patch[T, E](schema: Codec[T, E, object, object], /) -> Differ[T, JsonPatch]:
+    """A patch that changes nothing returns the old value itself. Patching decodes through
+    ``schema``'s JSON form, so a value it refuses raises ``SchemaError``."""
+    serializer: Any = to_codec_json(schema)
+    get = encode_sync(serializer)
+    set_ = decode_sync(serializer)
+
+    def patch(old_value: T, patch: JsonPatch) -> T:
+        value = get(old_value)
+        patched = json_patch.apply(patch, value)
+        return old_value if patched is value else set_(patched)
+
+    return Differ(
+        empty=[],
+        diff=lambda old_value, new_value: json_patch.get(get(old_value), get(new_value)),
+        combine=lambda first, second: [*first, *second],
+        patch=patch,
+    )

pyfect/schema/_to_encoder_xml.py

@@ -0,0 +1,119 @@
+"""``to_encoder_xml``: a value as XML text, through its string tree (Effect's
+``Schema.toEncoderXml``)."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, cast
+
+from pyfect._core import Effect
+from pyfect._js import js_number
+from pyfect.schema._error import SchemaError
+from pyfect.schema._parse import encode_effect
+from pyfect.schema._schema import Codec
+from pyfect.schema._to_codec_string_tree import to_codec_string_tree
+
+
+def to_encoder_xml[T, E, RD, RE](
+    codec: Codec[T, E, RD, RE],
+    /,
+    *,
+    root_name: str | None = None,
+    array_item_name: str = "item",
+    pretty: bool = True,
+    indent: str = "  ",
+    sort_keys: bool = True,
+) -> Callable[[T], Effect[str, SchemaError, RE]]:
+    """A function from a value to its XML text. The root is ``root_name``, else the schema's
+    identifier or title, else ``root``. A declaration with no codec is a ``ValueError``."""
+    resolved = codec.__codec__().ast.resolve() or {}
+    name = root_name or resolved.get("identifier") or resolved.get("title") or "root"
+    options = _Options(array_item_name, pretty, indent, sort_keys)
+    serialize: Callable[[T], Effect[Any, SchemaError, RE]] = encode_effect(
+        to_codec_string_tree(codec)
+    )
+    return lambda value: serialize(value).map(lambda tree: _to_xml(str(name), tree, options))
+
+
+@dataclass(frozen=True, slots=True)
+class _Options:
+    array_item_name: str
+    pretty: bool
+    indent: str
+    sort_keys: bool
+
+
+def _to_xml(root_name: str, tree: object, options: _Options) -> str:
+    lines: list[str] = []
+    seen: set[int] = set()
+
+    def push(depth: int, text: str) -> None:
+        lines.append(options.indent * depth + text if options.pretty else text)
+
+    def container(
+        tag: str, attrs: str, depth: int, node: object, children: Sequence[tuple[str, object, str]]
+    ) -> None:
+        if id(node) in seen:
+            raise ValueError("Cycle detected while serializing to XML.")
+        if not children:
+            push(depth, f"<{tag}{attrs}/>")
+            return
+        seen.add(id(node))
+        push(depth, f"<{tag}{attrs}>")
+        for child_name, child, original in children:
+            recur(child_name, child, depth + 1, original)
+        push(depth, f"</{tag}>")
+        seen.discard(id(node))
+
+    def recur(name: str, node: object, depth: int, original: str | None) -> None:
+        tag, attrs = _tag_info(name, original)
+        match node:
+            case None:
+                push(depth, f"<{tag}{attrs}/>")
+            case str():
+                push(depth, f"<{tag}{attrs}>{_escape_text(node)}</{tag}>")
+            case Mapping():
+                entries = cast("Mapping[str, object]", node)
+                keys = sorted(entries) if options.sort_keys else list(entries)
+                children = [(_safe_name(key), entries[key], key) for key in keys]
+                container(tag, attrs, depth, entries, children)
+            case list() | tuple():
+                items = cast("Sequence[object]", node)
+                item = options.array_item_name
+                container(tag, attrs, depth, items, [(item, value, item) for value in items])
+            case _:
+                push(depth, f"<{tag}{attrs}>{_escape_text(_format(node))}</{tag}>")
+
+    recur(root_name, tree, 0, None)
+    return ("\n" if options.pretty else "").join(lines)
+
+
+def _format(value: object) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return js_number(value) if isinstance(value, int | float) else str(value)
+
+
+def _escape_text(value: str) -> str:
+    return value.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+def _escape_attribute(value: str) -> str:
+    return (
+        value.replace("&", "&amp;").replace('"', "&quot;").replace("<", "&lt;").replace(">", "&gt;")
+    )
+
+
+def _safe_name(name: str) -> str:
+    safe = name if re.match(r"[A-Za-z_]", name) else "_" + name
+    safe = re.sub(r"[^A-Za-z0-9._-]", "_", safe)
+    return "_" + safe if re.match(r"xml", safe, re.IGNORECASE) else safe
+
+
+def _tag_info(name: str, original: str | None) -> tuple[str, str]:
+    safe = _safe_name(name)
+    if safe != name or (original and original != name):
+        return safe, f' data-name="{_escape_attribute(original or name)}"'
+    return safe, ""