fpml-convert 0.6.0__tar.gz

fpml_convert-0.6.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: fpml-convert
+Version: 0.6.0
+Summary: FpML interest-rate-swap XML <-> JSON, standard library only. One projection mapping, also shipped as a JS interpreter and a C++17 converter.
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://danieltuzes.github.io/fpml-convert/
+Project-URL: Source, https://github.com/danieltuzes/fpml-convert
+Keywords: fpml,xml,json,structile,derivatives,swap
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# fpml-convert (Python)
+
+Standard-library-only conversion between **FpML interest-rate-swap XML and
+plain JSON**, in both directions. No `lxml`, no third-party JSON — just
+`xml.etree.ElementTree` and `json`.
+
+One projection mapping, also implemented as a JavaScript interpreter (for
+the [Structile](https://danieltuzes.github.io/structile/) viewer) and a
+pure-STL C++17 converter; the three agree byte-for-byte on a shared test
+corpus. Downloads, the full version archive, and the mapping's precise
+rules: <https://danieltuzes.github.io/fpml-convert/>.
+
+## Install
+
+```sh
+pip install fpml-convert
+```
+
+No runtime dependencies. Python 3.8+.
+
+## Use
+
+```python
+from fpml_convert import fpml_to_json, json_to_fpml
+
+value = fpml_to_json(xml_text)      # -> dict
+xml_text2 = json_to_fpml(value)     # -> schema-ordered FpML, round-trips at the value level
+```
+
+```sh
+# CLI (direction inferred from the input, or forced with --to)
+python -m fpml_convert swap.xml  -o swap.json
+python -m fpml_convert swap.json -o swap.xml
+cat swap.xml | python -m fpml_convert - > swap.json
+```
+
+## The mapping
+
+- Element local name → object key; a tag repeated under one parent → an
+  array in document order.
+- Namespace prefixes and ElementTree Clark notation (`{uri}local`) are both
+  reduced to the local name, so the result is identical across a browser
+  `DOMParser` and a server-side parser.
+- Attributes → `@`-prefixed keys, before any child keys, ordered `@id`,
+  `@xsi:type`, `@href`, then the rest. `xsi:type` is kept verbatim.
+- A pure reference element (`href`, no children) → the scalar `«id»`;
+  Structile renders that as a link to the element whose `@id` matches.
+- Typed lexical forms are preserved as strings, never coerced
+  (`1000000.00` stays exactly that).
+- Every element the projection descends into is checked against a
+  supported-subset allowlist — an unknown element raises
+  `FpmlUnsupportedError` rather than projecting partially.
+- Serialization re-emits children in schema (`xs:sequence`) order.
+
+## Scope
+
+FpML 5.10 confirmation view, interest-rate **swap** `dataDocument` only. A
+non-IR-swap document raises `ValueError`. FRA and other products widen the
+allowlist in later releases. An FpML-AWG interchange-shape mode is planned.
+
+## License
+
+Apache-2.0. The FpML example files used for testing are redistributed
+under the [FpML Public License](https://www.fpml.org/the_standard/fpml-public-license/).

fpml_convert-0.6.0/README.md

@@ -0,0 +1,64 @@
+# fpml-convert (Python)
+
+Standard-library-only conversion between **FpML interest-rate-swap XML and
+plain JSON**, in both directions. No `lxml`, no third-party JSON — just
+`xml.etree.ElementTree` and `json`.
+
+One projection mapping, also implemented as a JavaScript interpreter (for
+the [Structile](https://danieltuzes.github.io/structile/) viewer) and a
+pure-STL C++17 converter; the three agree byte-for-byte on a shared test
+corpus. Downloads, the full version archive, and the mapping's precise
+rules: <https://danieltuzes.github.io/fpml-convert/>.
+
+## Install
+
+```sh
+pip install fpml-convert
+```
+
+No runtime dependencies. Python 3.8+.
+
+## Use
+
+```python
+from fpml_convert import fpml_to_json, json_to_fpml
+
+value = fpml_to_json(xml_text)      # -> dict
+xml_text2 = json_to_fpml(value)     # -> schema-ordered FpML, round-trips at the value level
+```
+
+```sh
+# CLI (direction inferred from the input, or forced with --to)
+python -m fpml_convert swap.xml  -o swap.json
+python -m fpml_convert swap.json -o swap.xml
+cat swap.xml | python -m fpml_convert - > swap.json
+```
+
+## The mapping
+
+- Element local name → object key; a tag repeated under one parent → an
+  array in document order.
+- Namespace prefixes and ElementTree Clark notation (`{uri}local`) are both
+  reduced to the local name, so the result is identical across a browser
+  `DOMParser` and a server-side parser.
+- Attributes → `@`-prefixed keys, before any child keys, ordered `@id`,
+  `@xsi:type`, `@href`, then the rest. `xsi:type` is kept verbatim.
+- A pure reference element (`href`, no children) → the scalar `«id»`;
+  Structile renders that as a link to the element whose `@id` matches.
+- Typed lexical forms are preserved as strings, never coerced
+  (`1000000.00` stays exactly that).
+- Every element the projection descends into is checked against a
+  supported-subset allowlist — an unknown element raises
+  `FpmlUnsupportedError` rather than projecting partially.
+- Serialization re-emits children in schema (`xs:sequence`) order.
+
+## Scope
+
+FpML 5.10 confirmation view, interest-rate **swap** `dataDocument` only. A
+non-IR-swap document raises `ValueError`. FRA and other products widen the
+allowlist in later releases. An FpML-AWG interchange-shape mode is planned.
+
+## License
+
+Apache-2.0. The FpML example files used for testing are redistributed
+under the [FpML Public License](https://www.fpml.org/the_standard/fpml-public-license/).

fpml_convert-0.6.0/fpml_convert/__init__.py

@@ -0,0 +1,40 @@
+"""fpml_convert — FpML interest-rate-swap XML <-> JSON, standard library only.
+
+The Python sibling of ``structile-fpml``'s JavaScript interpreter bundle.
+Same projection mapping (the ``@``-prefixed, ``«id»``-reference,
+local-name-reduced one that round-trips without the schema), same
+supported-element subset and ``xs:sequence`` child-order binding — both
+read from the shared ``src/rules.json``.
+
+>>> from fpml_convert import fpml_to_json, json_to_fpml
+>>> value = fpml_to_json(xml_text)      # -> dict, == the JS bundle's output
+>>> xml_text2 = json_to_fpml(value)     # -> schema-ordered FpML
+
+A ``--mapping fpml-awg`` interchange mode (the ISDA FpML AWG "Guidelines on
+FpML to JSON Conversion" shape) is planned; this module ships only the
+structile projection for now.
+"""
+from __future__ import annotations
+
+from ._project import (
+    FpmlUnsupportedError,
+    LINK_CLOSE,
+    LINK_ID_FIELD,
+    LINK_OPEN,
+    fpml_to_json,
+)
+from ._serialize import json_to_fpml
+
+#: FpML schema version this converter targets. Mirrors the JS bundle's
+#: ``INTERPRETER_VERSION`` / ``package.json`` ``fpmlVersion``.
+FPML_VERSION = "5.10"
+
+__all__ = [
+    "fpml_to_json",
+    "json_to_fpml",
+    "FpmlUnsupportedError",
+    "FPML_VERSION",
+    "LINK_OPEN",
+    "LINK_CLOSE",
+    "LINK_ID_FIELD",
+]

fpml_convert-0.6.0/fpml_convert/__main__.py

@@ -0,0 +1,49 @@
+"""``python -m fpml_convert IN [-o OUT]`` — convert an FpML IR-swap
+``dataDocument`` between XML and JSON, direction inferred from the input
+(``<`` first non-space char -> XML -> JSON, else JSON -> XML) or forced
+with ``--to xml|json``.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import FPML_VERSION, fpml_to_json, json_to_fpml
+
+
+def _looks_like_xml(text: str) -> bool:
+    stripped = text.lstrip()
+    return stripped.startswith("<")
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(
+        prog="python -m fpml_convert",
+        description="FpML interest-rate-swap XML <-> JSON (structile projection).",
+    )
+    p.add_argument("input", help="path to an FpML .xml or a projected .json file, or - for stdin")
+    p.add_argument("-o", "--output", help="write here instead of stdout")
+    p.add_argument("--to", choices=("xml", "json"), help="force the output direction")
+    p.add_argument("--indent", type=int, default=2, help="JSON indent (default 2)")
+    p.add_argument("--version", action="version", version=f"fpml_convert (FpML {FPML_VERSION})")
+    args = p.parse_args(argv)
+
+    text = sys.stdin.read() if args.input == "-" else open(args.input, encoding="utf-8").read()
+
+    to = args.to or ("json" if _looks_like_xml(text) else "xml")
+    if to == "json":
+        out_text = json.dumps(fpml_to_json(text), indent=args.indent, ensure_ascii=False) + "\n"
+    else:
+        out_text = json_to_fpml(json.loads(text))
+
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as fh:
+            fh.write(out_text)
+    else:
+        sys.stdout.write(out_text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fpml_convert-0.6.0/fpml_convert/_project.py

@@ -0,0 +1,225 @@
+"""FpML XML -> plain value projection — a faithful port of the JS bundle's
+``src/20-ns.js`` + ``src/30-project.js`` + ``src/40-support.js`` +
+``src/50-swap.js``. The rule tables come from the shared ``src/rules.json``
+(see :mod:`fpml_convert._rules`); only this traversal logic is duplicated
+between the two implementations, and the committed JS snapshots
+(``test/__snapshots__/*.json``) are the cross-language contract.
+
+Projection rules (identical to the JS interpreter):
+
+* element local name -> key; a repeated tag under one parent -> a list,
+  in document order.
+* attributes -> ``@``-prefixed keys: ``@id`` first, then ``@xsi:type``,
+  then ``@href``, then any other plain attribute, all BEFORE the child
+  keys. ``xmlns*`` and other ``xsi:*`` attributes are dropped.
+* a pure reference element (``href``, nothing else) -> the link scalar
+  ``«href»``. One that also carries content stays a dict but still gets
+  ``@href = «href»``.
+* ``xsi:type`` -> ``@xsi:type`` verbatim. Typed lexical forms are NEVER
+  coerced — every leaf value stays the exact source string.
+* every element descended into is checked against ``FPML_SUPPORTED``
+  first; an unknown element is a loud error, not a best-effort guess.
+"""
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+
+from ._rules import FPML_SUPPORTED
+
+LINK_OPEN = "«"   # «
+LINK_CLOSE = "»"  # »
+LINK_ID_FIELD = "@id"
+
+_XSI_NS = "http://www.w3.org/2001/XMLSchema-instance"
+
+
+class FpmlUnsupportedError(Exception):
+    """Raised for an element outside the supported IR-swap subset. A
+    structural "I don't recognise this" — distinct from the soft rule
+    violations Structile's ``__structileDiagnostic`` is for."""
+
+
+def fpml_local_name(name) -> str:
+    """``{uri}local`` -> ``local``; ``prefix:local`` -> ``local``;
+    ``local`` -> ``local``. Reduces both DOM providers' spellings."""
+    t = "" if name is None else str(name)
+    brace = t.rfind("}")
+    if brace != -1:
+        return t[brace + 1:]
+    colon = t.rfind(":")
+    return t[colon + 1:] if colon != -1 else t
+
+
+def fpml_element_local_name(el) -> str:
+    return fpml_local_name(getattr(el, "tag", None))
+
+
+def _attr_items(el):
+    """``el.attrib`` items in source order (ElementTree preserves it since
+    Python 3.8)."""
+    return list(el.attrib.items())
+
+
+def fpml_xsi_type(el):
+    for raw, val in _attr_items(el):
+        if raw == "xsi:type":
+            return val
+        if raw.startswith("{") and "}" in raw:
+            uri = raw[1:raw.index("}")]
+            if uri == _XSI_NS and fpml_local_name(raw) == "type":
+                return val
+    return None
+
+
+def fpml_plain_attributes(el):
+    """Non-namespaced "business" attributes as an ordered ``dict``, with the
+    structural ones removed: ``xmlns*``, ``xsi:*`` (``xsi:type`` / ``xsi:nil``
+    are surfaced separately), and ``id`` / ``href`` (projected explicitly as
+    ``@id`` / ``@href``)."""
+    out = {}
+    for raw, val in _attr_items(el):
+        if raw == "xmlns" or raw.startswith("xmlns:"):
+            continue
+        if raw in ("id", "href"):
+            continue
+        if raw.startswith("{"):
+            uri = raw[1:raw.index("}")]
+            if uri == _XSI_NS:
+                continue
+        elif raw.startswith("xsi:"):
+            continue
+        out[fpml_local_name(raw)] = val
+    return out
+
+
+def fpml_is_xsi_nil(el) -> bool:
+    for raw, val in _attr_items(el):
+        is_nil_attr = raw == "xsi:nil" or (
+            raw.startswith("{") and "}" in raw
+            and fpml_local_name(raw) == "nil" and raw[1:raw.index("}")] == _XSI_NS
+        )
+        if is_nil_attr:
+            return str(val).strip() == "true"
+    return False
+
+
+def fpml_own_text(el) -> str:
+    """A leaf element's own trimmed text, or ``""``. Only ever called on a
+    childless element, so ``el.text`` IS its whole text."""
+    return (el.text or "").strip()
+
+
+def _wrap_ref(id_: str) -> str:
+    return LINK_OPEN + id_ + LINK_CLOSE
+
+
+def fpml_assert_supported(el) -> None:
+    name = fpml_element_local_name(el)
+    if name not in FPML_SUPPORTED:
+        raise FpmlUnsupportedError(
+            "fpml converter (read-only IR-swap subset): element <" + name + "> "
+            "is outside the supported subset. This is by design — the subset "
+            "is widened only as real FpML example files are added to the test "
+            "corpus."
+        )
+
+
+def fpml_project_element(el):
+    fpml_assert_supported(el)
+
+    id_ = el.get("id")
+    href = el.get("href")
+    xsi_type = fpml_xsi_type(el)
+    is_nil = fpml_is_xsi_nil(el)
+    plain = fpml_plain_attributes(el)
+    kids = list(el)
+    has_plain = len(plain) > 0
+
+    # Pure reference: href, nothing else of substance.
+    if href is not None and not kids and not has_plain and xsi_type is None and fpml_own_text(el) == "":
+        return _wrap_ref(href)
+
+    # Childless: a scalar (or a small dict when it has attributes to keep).
+    if not kids:
+        text = fpml_own_text(el)
+        bare = None if is_nil else (None if text == "" else text)
+        if id_ is None and href is None and xsi_type is None and not has_plain:
+            return bare
+        leaf = {}
+        if id_ is not None:
+            leaf["@id"] = str(id_)
+        if xsi_type is not None:
+            leaf["@xsi:type"] = str(xsi_type)
+        if href is not None:
+            leaf["@href"] = _wrap_ref(href)
+        for k, v in plain.items():
+            leaf["@" + k] = v
+        if is_nil:
+            leaf["@xsi:nil"] = "true"
+        if text != "":
+            leaf["#text"] = text
+        return leaf
+
+    # Container: attributes first (fixed order), then grouped children.
+    out = {}
+    if id_ is not None:
+        out["@id"] = str(id_)
+    if xsi_type is not None:
+        out["@xsi:type"] = str(xsi_type)
+    if href is not None:
+        out["@href"] = _wrap_ref(href)
+    for k, v in plain.items():
+        out["@" + k] = v
+    if is_nil:
+        out["@xsi:nil"] = "true"
+
+    order = []
+    groups = {}
+    for kid in kids:
+        key = fpml_element_local_name(kid)
+        if key not in groups:
+            groups[key] = []
+            order.append(key)
+        groups[key].append(kid)
+    for key in order:
+        g = groups[key]
+        out[key] = fpml_project_element(g[0]) if len(g) == 1 else [fpml_project_element(x) for x in g]
+    return out
+
+
+def _has_descendant(root, local_name: str) -> bool:
+    return any(fpml_element_local_name(e) == local_name for e in root.iter())
+
+
+def fpml_assert_is_ir_swap_data_document(root) -> None:
+    """Root gate — the throw that tells interpreter selection FpML apart
+    from every other candidate. Rejects anything that isn't an FpML
+    interest-rate-swap ``<dataDocument>``."""
+    if root is None or fpml_element_local_name(root) != "dataDocument":
+        got = fpml_element_local_name(root) if root is not None else "?"
+        raise ValueError(
+            "fpml converter: expected a root <dataDocument> element, got <" + got + "> "
+            "— this doesn't look like an FpML dataDocument."
+        )
+    ver = root.get("fpmlVersion")
+    if ver is not None and not str(ver).startswith("5-"):
+        raise ValueError(
+            'fpml converter: fpmlVersion="' + str(ver) + '" is not an FpML 5.x document.'
+        )
+    if not _has_descendant(root, "swap"):
+        raise ValueError(
+            "fpml converter: this <dataDocument> contains no <swap> — only the "
+            "interest-rate-swap product family is supported in this read-only build."
+        )
+
+
+def fpml_to_json(xml_text: str):
+    """FpML interest-rate-swap XML -> the nested value Structile renders.
+
+    Raises :class:`ValueError` if the document isn't an FpML IR-swap
+    ``dataDocument``, or :class:`FpmlUnsupportedError` for an element
+    outside the supported subset.
+    """
+    root = ET.fromstring(xml_text)
+    fpml_assert_is_ir_swap_data_document(root)
+    return fpml_project_element(root)

fpml_convert-0.6.0/fpml_convert/_rules.py

@@ -0,0 +1,40 @@
+"""Loads the language-neutral projection rule tables from ``src/rules.json``
+— the SAME file ``scripts/build.mjs`` injects into the JS bundle as
+``const FPML_RULES``. One source of truth for the supported-element set and
+the ``xs:sequence`` child-order binding across both implementations.
+
+Lookup order:
+  1. ``rules.json`` sitting next to this package (a packaging step copies
+     it there for the wheel — see the FpML interpreter plan Phase 8);
+  2. ``../../src/rules.json`` relative to this file (a repo checkout).
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+_HERE = Path(__file__).resolve().parent
+
+
+def _locate() -> Path:
+    packaged = _HERE / "rules.json"
+    if packaged.is_file():
+        return packaged
+    repo_copy = _HERE.parents[1] / "src" / "rules.json"
+    if repo_copy.is_file():
+        return repo_copy
+    raise FileNotFoundError(
+        "fpml_convert: rules.json not found next to the package or at "
+        f"{repo_copy} — a repo checkout or a packaged copy is required"
+    )
+
+
+_RAW = json.loads(_locate().read_text(encoding="utf-8"))
+
+#: ``set`` of every element local-name the projection is allowed to descend
+#: into; anything else is a :class:`~fpml_convert.FpmlUnsupportedError`.
+FPML_SUPPORTED: frozenset = frozenset(_RAW["supported"])
+
+#: ``{parent_local_name: [child_local_name, ...]}`` — serialize re-emits a
+#: dict's children in this order, not the (user-editable) key order.
+FPML_CHILD_ORDER: dict = dict(_RAW["childOrder"])

fpml_convert-0.6.0/fpml_convert/_serialize.py

@@ -0,0 +1,124 @@
+"""Value -> FpML XML — the inverse of :func:`fpml_convert._project.fpml_to_json`,
+a faithful port of the JS bundle's ``src/70-serialize.js`` (which uses the
+shared ``FPML_CHILD_ORDER`` from ``src/rules.json``). Round-trips at the
+VALUE level: ``fpml_to_json(json_to_fpml(fpml_to_json(x))) == fpml_to_json(x)``.
+
+Policies, matching the JS side exactly:
+
+* typed lexical forms are written back verbatim (no coercion — ``1000000``
+  vs ``1000000.00`` survives);
+* the confirmation-view default namespace + ``xsi:`` are re-declared on the
+  root; ``xsi:schemaLocation`` is not reproduced;
+* children are re-emitted in ``FPML_CHILD_ORDER`` order, so a value whose
+  keys were reordered still serialises as schema-ordered FpML.
+"""
+from __future__ import annotations
+
+from ._project import LINK_CLOSE, LINK_OPEN
+from ._rules import FPML_CHILD_ORDER
+
+_FPML_CONFIRMATION_NS = "http://www.fpml.org/FpML-5/confirmation"
+_FPML_XSI_NS = "http://www.w3.org/2001/XMLSchema-instance"
+
+
+def _esc_attr(s) -> str:
+    return (str(s).replace("&", "&amp;").replace("<", "&lt;")
+            .replace(">", "&gt;").replace('"', "&quot;"))
+
+
+def _esc_text(s) -> str:
+    return str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+def _is_ref(v) -> bool:
+    return isinstance(v, str) and v.startswith(LINK_OPEN) and v.endswith(LINK_CLOSE)
+
+
+def _unwrap_ref(v: str) -> str:
+    return v[len(LINK_OPEN):len(v) - len(LINK_CLOSE)]
+
+
+def _order_child_pairs(parent_local_name, pairs):
+    order = FPML_CHILD_ORDER.get(parent_local_name)
+    if not order:
+        return pairs
+    rank = {name: i for i, name in enumerate(order)}
+    decorated = [
+        (rank[p[0]] if p[0] in rank else len(order) + i, i, p)
+        for i, p in enumerate(pairs)
+    ]
+    decorated.sort(key=lambda t: (t[0], t[1]))
+    return [t[2] for t in decorated]
+
+
+def _serialize_value(key, val, indent, out):
+    if isinstance(val, list):
+        for item in val:
+            _serialize_value(key, item, indent, out)
+        return
+    if val is None:
+        out.append(indent + "<" + key + "/>")
+        return
+    if not isinstance(val, dict):
+        if _is_ref(val):
+            out.append(indent + "<" + key + ' href="' + _esc_attr(_unwrap_ref(val)) + '"/>')
+        else:
+            out.append(indent + "<" + key + ">" + _esc_text(val) + "</" + key + ">")
+        return
+
+    attrs = []
+    nil = False
+    text = None
+    child_pairs = []
+    for k in val:
+        if k == "@xsi:nil":
+            nil = str(val[k]) == "true"
+        elif k == "@id":
+            attrs.append(("id", val[k]))
+        elif k == "@xsi:type":
+            attrs.append(("xsi:type", val[k]))
+        elif k == "@href":
+            attrs.append(("href", _unwrap_ref(val[k]) if _is_ref(val[k]) else val[k]))
+        elif k.startswith("@"):
+            attrs.append((k[1:], val[k]))
+        elif k == "#text":
+            text = val[k]
+        else:
+            child_pairs.append((k, val[k]))
+
+    attr_str = "".join(' %s="%s"' % (name, _esc_attr(v)) for name, v in attrs)
+    if nil:
+        attr_str += ' xsi:nil="true"'
+    open_tag = "<" + key + attr_str
+
+    if nil or (not child_pairs and text is None):
+        out.append(indent + open_tag + "/>")
+        return
+    if not child_pairs:
+        out.append(indent + open_tag + ">" + _esc_text(text) + "</" + key + ">")
+        return
+
+    out.append(indent + open_tag + ">")
+    ci = indent + "  "
+    if text is not None:
+        out.append(ci + _esc_text(text))   # mixed content (not seen in the subset)
+    for cp in _order_child_pairs(key, child_pairs):
+        _serialize_value(cp[0], cp[1], ci, out)
+    out.append(indent + "</" + key + ">")
+
+
+def json_to_fpml(value) -> str:
+    """The projected ``dataDocument`` value -> FpML text."""
+    if not isinstance(value, dict):
+        raise ValueError("fpml json_to_fpml: expected the projected <dataDocument> object")
+    ver = value["@fpmlVersion"] if isinstance(value.get("@fpmlVersion"), str) else "5-10"
+    out = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<dataDocument xmlns="%s" xmlns:xsi="%s" fpmlVersion="%s">'
+        % (_FPML_CONFIRMATION_NS, _FPML_XSI_NS, _esc_attr(ver)),
+    ]
+    child_pairs = [(k, value[k]) for k in value if not k.startswith("@")]
+    for cp in _order_child_pairs("dataDocument", child_pairs):
+        _serialize_value(cp[0], cp[1], "  ", out)
+    out.append("</dataDocument>")
+    return "\n".join(out) + "\n"

fpml_convert-0.6.0/fpml_convert/rules.json

@@ -0,0 +1,97 @@
+{
+  "_comment": "Language-neutral FpML projection rule tables, the single source of truth shared by the JS bundle (injected by scripts/build.mjs as `const FPML_RULES`, consumed by src/40-support.js and src/60-binding.js) and the Python converter (python/fpml_convert/_rules.py). Widen the same way as before: against a real corpus file or the FpML 5.10 XSD, never speculatively. See src/40-support.js and src/60-binding.js headers for the rationale behind each table.",
+
+  "supported": [
+    "dataDocument", "trade", "tradeHeader", "partyTradeIdentifier",
+    "partyReference", "tradeId", "tradeDate", "party", "partyId", "partyName",
+    "calculationAgent", "calculationAgentPartyReference",
+
+    "swap", "swapStream",
+    "payerPartyReference", "receiverPartyReference",
+
+    "calculationPeriodDates", "effectiveDate", "terminationDate",
+    "unadjustedDate", "adjustedStartDate", "adjustedEndDate",
+    "dateAdjustments", "businessDayConvention", "businessCenters",
+    "businessCenter", "businessCentersReference",
+    "calculationPeriodDatesAdjustments", "calculationPeriodFrequency",
+    "periodMultiplier", "period", "rollConvention",
+    "firstPeriodStartDate", "firstRegularPeriodStartDate",
+    "lastRegularPeriodEndDate", "firstPaymentDate",
+    "stubCalculationPeriodAmount", "initialStub", "finalStub", "stubRate",
+
+    "paymentDates", "calculationPeriodDatesReference", "paymentFrequency",
+    "payRelativeTo", "paymentDatesAdjustments", "paymentDaysOffset",
+    "adjustedPaymentDate", "paymentDate",
+
+    "resetDates", "resetRelativeTo", "fixingDates", "dayType", "dateRelativeTo",
+    "resetFrequency", "resetDatesAdjustments", "adjustedFixingDate",
+
+    "calculationPeriodAmount", "calculation", "compoundingMethod",
+    "notionalSchedule", "notionalStepSchedule", "notionalAmount",
+    "initialValue", "currency", "step", "stepDate", "stepValue",
+    "fixedRateSchedule", "fixedRate", "spreadSchedule",
+    "floatingRateCalculation", "floatingRateDefinition", "floatingRate",
+    "floatingRateIndex", "indexTenor", "finalRateRounding",
+    "roundingDirection", "precision", "rateObservation", "observationWeight",
+    "dayCountFraction",
+
+    "calculationPeriod", "paymentCalculationPeriod",
+    "cashflows", "cashflowsMatchParameters", "additionalPayment",
+    "paymentAmount", "amount",
+
+    "principalExchanges", "initialExchange", "intermediateExchange",
+    "finalExchange", "principalExchange", "principalExchangeAmount",
+    "principalExchangeDate", "adjustedPrincipalExchangeDate"
+  ],
+
+  "childOrder": {
+    "additionalPayment": ["payerPartyReference", "receiverPartyReference", "paymentAmount", "paymentDate"],
+    "businessCenters": ["businessCenter"],
+    "calculation": ["notionalSchedule", "fixedRateSchedule", "floatingRateCalculation", "dayCountFraction", "compoundingMethod"],
+    "calculationAgent": ["calculationAgentPartyReference"],
+    "calculationPeriod": ["adjustedStartDate", "adjustedEndDate", "notionalAmount", "floatingRateDefinition", "fixedRate"],
+    "calculationPeriodAmount": ["calculation"],
+    "calculationPeriodDates": ["effectiveDate", "terminationDate", "calculationPeriodDatesAdjustments", "firstPeriodStartDate", "firstRegularPeriodStartDate", "lastRegularPeriodEndDate", "calculationPeriodFrequency"],
+    "calculationPeriodDatesAdjustments": ["businessDayConvention", "businessCentersReference", "businessCenters"],
+    "calculationPeriodFrequency": ["periodMultiplier", "period", "rollConvention"],
+    "cashflows": ["cashflowsMatchParameters", "principalExchange", "paymentCalculationPeriod"],
+    "dataDocument": ["trade", "party"],
+    "dateAdjustments": ["businessDayConvention", "businessCenters", "businessCentersReference"],
+    "effectiveDate": ["unadjustedDate", "dateAdjustments"],
+    "finalRateRounding": ["roundingDirection", "precision"],
+    "finalStub": ["floatingRate"],
+    "firstPeriodStartDate": ["unadjustedDate", "dateAdjustments"],
+    "fixedRateSchedule": ["initialValue", "step"],
+    "fixingDates": ["periodMultiplier", "period", "dayType", "businessDayConvention", "businessCenters", "dateRelativeTo"],
+    "floatingRate": ["floatingRateIndex", "indexTenor"],
+    "floatingRateCalculation": ["floatingRateIndex", "indexTenor", "finalRateRounding", "spreadSchedule"],
+    "floatingRateDefinition": ["rateObservation"],
+    "indexTenor": ["periodMultiplier", "period"],
+    "initialStub": ["floatingRate", "stubRate"],
+    "notionalSchedule": ["notionalStepSchedule"],
+    "notionalStepSchedule": ["initialValue", "step", "currency"],
+    "party": ["partyId", "partyName"],
+    "partyTradeIdentifier": ["partyReference", "tradeId"],
+    "paymentAmount": ["currency", "amount"],
+    "paymentCalculationPeriod": ["adjustedPaymentDate", "calculationPeriod"],
+    "paymentDate": ["unadjustedDate", "dateAdjustments"],
+    "paymentDates": ["calculationPeriodDatesReference", "paymentFrequency", "firstPaymentDate", "payRelativeTo", "paymentDaysOffset", "paymentDatesAdjustments"],
+    "paymentDatesAdjustments": ["businessDayConvention", "businessCentersReference", "businessCenters"],
+    "paymentDaysOffset": ["periodMultiplier", "period", "dayType"],
+    "paymentFrequency": ["periodMultiplier", "period"],
+    "principalExchange": ["adjustedPrincipalExchangeDate", "principalExchangeAmount"],
+    "principalExchanges": ["initialExchange", "finalExchange", "intermediateExchange"],
+    "rateObservation": ["adjustedFixingDate", "observationWeight"],
+    "resetDates": ["calculationPeriodDatesReference", "resetRelativeTo", "fixingDates", "resetFrequency", "resetDatesAdjustments"],
+    "resetDatesAdjustments": ["businessDayConvention", "businessCentersReference", "businessCenters"],
+    "resetFrequency": ["periodMultiplier", "period"],
+    "spreadSchedule": ["initialValue"],
+    "step": ["stepDate", "stepValue"],
+    "stubCalculationPeriodAmount": ["calculationPeriodDatesReference", "initialStub", "finalStub"],
+    "swap": ["swapStream", "additionalPayment"],
+    "swapStream": ["payerPartyReference", "receiverPartyReference", "calculationPeriodDates", "paymentDates", "resetDates", "calculationPeriodAmount", "stubCalculationPeriodAmount", "principalExchanges", "cashflows"],
+    "terminationDate": ["unadjustedDate", "dateAdjustments"],
+    "trade": ["tradeHeader", "swap", "calculationAgent", "fra"],
+    "tradeHeader": ["partyTradeIdentifier", "tradeDate"]
+  }
+}

fpml_convert-0.6.0/fpml_convert.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: fpml-convert
+Version: 0.6.0
+Summary: FpML interest-rate-swap XML <-> JSON, standard library only. One projection mapping, also shipped as a JS interpreter and a C++17 converter.
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://danieltuzes.github.io/fpml-convert/
+Project-URL: Source, https://github.com/danieltuzes/fpml-convert
+Keywords: fpml,xml,json,structile,derivatives,swap
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# fpml-convert (Python)
+
+Standard-library-only conversion between **FpML interest-rate-swap XML and
+plain JSON**, in both directions. No `lxml`, no third-party JSON — just
+`xml.etree.ElementTree` and `json`.
+
+One projection mapping, also implemented as a JavaScript interpreter (for
+the [Structile](https://danieltuzes.github.io/structile/) viewer) and a
+pure-STL C++17 converter; the three agree byte-for-byte on a shared test
+corpus. Downloads, the full version archive, and the mapping's precise
+rules: <https://danieltuzes.github.io/fpml-convert/>.
+
+## Install
+
+```sh
+pip install fpml-convert
+```
+
+No runtime dependencies. Python 3.8+.
+
+## Use
+
+```python
+from fpml_convert import fpml_to_json, json_to_fpml
+
+value = fpml_to_json(xml_text)      # -> dict
+xml_text2 = json_to_fpml(value)     # -> schema-ordered FpML, round-trips at the value level
+```
+
+```sh
+# CLI (direction inferred from the input, or forced with --to)
+python -m fpml_convert swap.xml  -o swap.json
+python -m fpml_convert swap.json -o swap.xml
+cat swap.xml | python -m fpml_convert - > swap.json
+```
+
+## The mapping
+
+- Element local name → object key; a tag repeated under one parent → an
+  array in document order.
+- Namespace prefixes and ElementTree Clark notation (`{uri}local`) are both
+  reduced to the local name, so the result is identical across a browser
+  `DOMParser` and a server-side parser.
+- Attributes → `@`-prefixed keys, before any child keys, ordered `@id`,
+  `@xsi:type`, `@href`, then the rest. `xsi:type` is kept verbatim.
+- A pure reference element (`href`, no children) → the scalar `«id»`;
+  Structile renders that as a link to the element whose `@id` matches.
+- Typed lexical forms are preserved as strings, never coerced
+  (`1000000.00` stays exactly that).
+- Every element the projection descends into is checked against a
+  supported-subset allowlist — an unknown element raises
+  `FpmlUnsupportedError` rather than projecting partially.
+- Serialization re-emits children in schema (`xs:sequence`) order.
+
+## Scope
+
+FpML 5.10 confirmation view, interest-rate **swap** `dataDocument` only. A
+non-IR-swap document raises `ValueError`. FRA and other products widen the
+allowlist in later releases. An FpML-AWG interchange-shape mode is planned.
+
+## License
+
+Apache-2.0. The FpML example files used for testing are redistributed
+under the [FpML Public License](https://www.fpml.org/the_standard/fpml-public-license/).

fpml_convert-0.6.0/fpml_convert.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+fpml_convert/__init__.py
+fpml_convert/__main__.py
+fpml_convert/_project.py
+fpml_convert/_rules.py
+fpml_convert/_serialize.py
+fpml_convert/rules.json
+fpml_convert.egg-info/PKG-INFO
+fpml_convert.egg-info/SOURCES.txt
+fpml_convert.egg-info/dependency_links.txt
+fpml_convert.egg-info/entry_points.txt
+fpml_convert.egg-info/top_level.txt
+tests/test_parity.py

fpml_convert-0.6.0/fpml_convert.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fpml_convert-0.6.0/fpml_convert.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fpml-convert = fpml_convert.__main__:main

fpml_convert-0.6.0/fpml_convert.egg-info/top_level.txt

@@ -0,0 +1 @@
+fpml_convert

fpml_convert-0.6.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+# setuptools ships with every Python — so `python -m build --no-isolation`
+# needs no network (FpML interpreter plan Phase 8: the local artifact
+# assembly must run offline). rules.json is shipped as package data; a
+# repo checkout without a packaged copy falls back to ../../src/rules.json
+# (see fpml_convert/_rules.py).
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fpml-convert"
+# Tracks structile-fpml's package.json `version` (this repo's code semver),
+# NOT the FpML schema version (that's fpml_convert.FPML_VERSION / "5.10").
+version = "0.6.0"
+description = "FpML interest-rate-swap XML <-> JSON, standard library only. One projection mapping, also shipped as a JS interpreter and a C++17 converter."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "Apache-2.0"
+keywords = ["fpml", "xml", "json", "structile", "derivatives", "swap"]
+
+[project.urls]
+Homepage = "https://danieltuzes.github.io/fpml-convert/"
+# The projection source lives in a private repo; this public one hosts the
+# built artifacts, the version archive, and a pointer to the source.
+Source = "https://github.com/danieltuzes/fpml-convert"
+
+[project.scripts]
+fpml-convert = "fpml_convert.__main__:main"
+
+[tool.setuptools]
+packages = ["fpml_convert"]
+
+[tool.setuptools.package-data]
+# scripts/build_artifacts.mjs copies src/rules.json here before building
+# the wheel/sdist; it is gitignored (a checkout reads ../../src/rules.json).
+fpml_convert = ["rules.json"]

fpml_convert-0.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fpml_convert-0.6.0/tests/test_parity.py

@@ -0,0 +1,136 @@
+"""Cross-language parity + round-trip test for the Python converter.
+
+The JS bundle's committed snapshots (``test/__snapshots__/*.json``) are the
+contract: ``fpml_to_json`` here must reproduce them BYTE-FOR-BYTE (same key
+order, same ``JSON.stringify(v, null, 2) + "\\n"`` formatting), so the two
+implementations can never silently diverge on the shared corpus.
+
+Runs three ways:
+  * ``python python/tests/test_parity.py``   (plain script, exits non-zero on failure)
+  * ``python -m pytest python/tests``         (each check is a ``test_*``)
+  * ``npm run test:py``                       (wired in package.json)
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+_REPO = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(_REPO / "python"))
+
+from fpml_convert import FpmlUnsupportedError, fpml_to_json, json_to_fpml  # noqa: E402
+
+_CORPUS = _REPO / "test" / "corpus"
+_FIXTURES = _REPO / "test" / "fixtures"
+_SNAPS = _REPO / "test" / "__snapshots__"
+
+
+def _samples():
+    """(snapshot-name, xml-path) for every file the JS suite snapshots."""
+    out = [("ir-swap-minimal", _FIXTURES / "ir-swap-minimal.xml")]
+    for x in sorted(_CORPUS.glob("*.xml")):
+        out.append(("corpus-" + x.stem, x))
+    return out
+
+
+def test_projection_matches_the_js_snapshots_byte_for_byte():
+    for name, xml_path in _samples():
+        snap = _SNAPS / (name + ".json")
+        assert snap.is_file(), f"missing JS snapshot {snap.name} — run `npm run snapshots` in structile-fpml"
+        got = json.dumps(fpml_to_json(xml_path.read_text(encoding="utf-8")), indent=2, ensure_ascii=False) + "\n"
+        assert got == snap.read_text(encoding="utf-8"), (
+            f"{xml_path.name}: Python projection differs from the JS snapshot {snap.name}"
+        )
+
+
+def test_round_trips_every_sample_at_the_value_level():
+    for name, xml_path in _samples():
+        v1 = fpml_to_json(xml_path.read_text(encoding="utf-8"))
+        v2 = fpml_to_json(json_to_fpml(v1))
+        assert v2 == v1, f"{xml_path.name}: value changed across json_to_fpml -> fpml_to_json"
+
+
+def test_serialize_is_independent_of_key_order():
+    def scramble(node):
+        if isinstance(node, list):
+            return [scramble(n) for n in node]
+        if isinstance(node, dict):
+            return {k: scramble(node[k]) for k in reversed(list(node))}
+        return node
+
+    checked = 0
+    for name, xml_path in _samples():
+        original = fpml_to_json(xml_path.read_text(encoding="utf-8"))
+        scrambled = scramble(original)
+        assert json_to_fpml(scrambled) == json_to_fpml(original), (
+            f"{xml_path.name}: serialize output depends on key order — binding not applied"
+        )
+        assert fpml_to_json(json_to_fpml(scrambled)) == original, f"{xml_path.name}: lost data"
+        checked += 1
+    assert checked >= 8
+
+
+def test_rejects_documents_outside_the_subset():
+    # non-dataDocument root
+    try:
+        fpml_to_json("<FpML><foo/></FpML>")
+        assert False, "expected a ValueError for a non-dataDocument root"
+    except ValueError as e:
+        assert "root <dataDocument>" in str(e)
+
+    # dataDocument with no <swap>
+    no_swap = ('<dataDocument xmlns="http://www.fpml.org/FpML-5/confirmation" '
+               'fpmlVersion="5-10"><party id="P"><partyName>X</partyName></party></dataDocument>')
+    try:
+        fpml_to_json(no_swap)
+        assert False, "expected a ValueError for a <dataDocument> with no <swap>"
+    except ValueError as e:
+        assert "no <swap>" in str(e)
+
+    # a real FpML FRA example — <fra>, not <swap>, so the root gate rejects it
+    fra = _FIXTURES / "ird-ex08-fra.xml"
+    if fra.is_file():
+        try:
+            fpml_to_json(fra.read_text(encoding="utf-8"))
+            assert False, "expected the FRA fixture to be rejected"
+        except ValueError as e:
+            assert "no <swap>" in str(e)
+
+    # an element outside FPML_SUPPORTED
+    alien = _FIXTURES.joinpath("ir-swap-minimal.xml").read_text(encoding="utf-8").replace(
+        "<tradeDate>2024-01-15</tradeDate>",
+        "<tradeDate>2024-01-15</tradeDate><novationEvent/>",
+    )
+    try:
+        fpml_to_json(alien)
+        assert False, "expected FpmlUnsupportedError for <novationEvent>"
+    except FpmlUnsupportedError as e:
+        assert "<novationEvent>" in str(e)
+
+
+def test_json_to_fpml_rejects_a_non_datadocument_value():
+    for bad in (None, [1, 2, 3], "nope"):
+        try:
+            json_to_fpml(bad)
+            assert False, f"expected ValueError for {bad!r}"
+        except ValueError as e:
+            assert "expected the projected" in str(e)
+
+
+def _run():
+    checks = [v for k, v in sorted(globals().items()) if k.startswith("test_") and callable(v)]
+    failed = 0
+    for fn in checks:
+        try:
+            fn()
+            print(f"ok   {fn.__name__}")
+        except Exception as e:  # noqa: BLE001
+            failed += 1
+            print(f"FAIL {fn.__name__}: {e}")
+    print(f"\n{len(checks) - failed}/{len(checks)} passed")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(_run())