yeptris 0.1.0__tar.gz

yeptris-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: yeptris
+Version: 0.1.0
+Summary: YAML for Python at libleptris speed — an FFI-based (no C extension) binding over libyeptris, PyYAML-compatible
+Author-email: "Ribose Inc." <open.source@ribose.com>
+License: MIT
+Project-URL: Homepage, https://github.com/leptris/yeptris
+Project-URL: Source, https://github.com/leptris/yeptris-py
+Keywords: yaml,parser,libyaml,pyyaml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pyyaml; extra == "test"
+
+# yeptris — YAML for Python at libleptris speed
+
+An FFI-based (no C extension) YAML library over
+[libyeptris](https://github.com/leptris/yeptris) — the YAML
+counterpart of libleptris. PyYAML-compatible semantics, one shared
+library, zero compilation at install.
+
+## Install (development)
+
+```sh
+# the sibling C checkout: ~/src/leptris/yeptris
+cmake -B build -S . -DCMAKE_BUILD_TYPE=Release -DYEPTRIS_BUILD_SHARED=ON
+cmake --build build
+
+cd ~/src/leptris/yeptris-py
+YEPTRIS_LIB_PATH=../yeptris/build/src/libyeptris.dylib python3 -m pytest
+```
+
+Without `YEPTRIS_LIB_PATH` the loader falls back to a vendored
+`yeptris/_platform/<tag>/` copy, then to the sibling checkout's
+build directory. Any `libyeptris.{so,dylib,dll}` path works.
+
+## Usage
+
+```python
+import yeptris
+from yeptris import yaml  # PyYAML-compatible surface
+
+yaml.safe_load("name: yeptris\nrating: 10\n")
+# {'name': 'yeptris', 'rating': 10}
+
+yaml.safe_load_all("--- 1\n--- two\n")   # [1, 'two']
+yaml.safe_dump({"b": 2, "a": [1, "x"]})  # 'a:\n  - 1\n  - x\nb: 2\n'
+
+yeptris.load("k: v")        # the neutral surface
+yeptris.dump({"k": [1, 2]})
+```
+
+Typing follows PyYAML's SafeLoader (YAML 1.1 implicit typing):
+`yes/no/on/off` booleans, `0x`/leading-0/`0b`/sexagesimal integers,
+dot-required floats, timestamps with offsets, merge keys, anchor
+identity. Every deliberate divergence is pinned by a test.
+
+## Design
+
+One parse, one bulk drain: the record array and string arena are
+read in two FFI calls, then a pure-Python walk over the unpacked
+records — the FFI tax is O(1) per document, never per event (the
+same seam yeptris-ruby rides). The 36-byte record layout is
+ABI-pinned in the C header and mirrored in `_ffi.py`.
+
+## Performance
+
+`python3 bench.py` — same-process comparison against PyYAML (pure)
+and CSafeLoader/CDumper (libyaml C extensions):
+
+- **load**: 28-39x PyYAML pure, 3.8-6.1x CSafeLoader
+- **dump**: ~1.7x PyYAML pure, ~2x behind CDumper (which walks the
+  tree entirely in C — a no-C-extension design's ceiling is the
+  Python walk itself; the tree raises through ONE
+  `yeptris_document_build` call)
+
+Both directions are O(chunks) in FFI calls: loads drain records in
+two calls, dumps build through one flat entry array.

yeptris-0.1.0/README.md

@@ -0,0 +1,64 @@
+# yeptris — YAML for Python at libleptris speed
+
+An FFI-based (no C extension) YAML library over
+[libyeptris](https://github.com/leptris/yeptris) — the YAML
+counterpart of libleptris. PyYAML-compatible semantics, one shared
+library, zero compilation at install.
+
+## Install (development)
+
+```sh
+# the sibling C checkout: ~/src/leptris/yeptris
+cmake -B build -S . -DCMAKE_BUILD_TYPE=Release -DYEPTRIS_BUILD_SHARED=ON
+cmake --build build
+
+cd ~/src/leptris/yeptris-py
+YEPTRIS_LIB_PATH=../yeptris/build/src/libyeptris.dylib python3 -m pytest
+```
+
+Without `YEPTRIS_LIB_PATH` the loader falls back to a vendored
+`yeptris/_platform/<tag>/` copy, then to the sibling checkout's
+build directory. Any `libyeptris.{so,dylib,dll}` path works.
+
+## Usage
+
+```python
+import yeptris
+from yeptris import yaml  # PyYAML-compatible surface
+
+yaml.safe_load("name: yeptris\nrating: 10\n")
+# {'name': 'yeptris', 'rating': 10}
+
+yaml.safe_load_all("--- 1\n--- two\n")   # [1, 'two']
+yaml.safe_dump({"b": 2, "a": [1, "x"]})  # 'a:\n  - 1\n  - x\nb: 2\n'
+
+yeptris.load("k: v")        # the neutral surface
+yeptris.dump({"k": [1, 2]})
+```
+
+Typing follows PyYAML's SafeLoader (YAML 1.1 implicit typing):
+`yes/no/on/off` booleans, `0x`/leading-0/`0b`/sexagesimal integers,
+dot-required floats, timestamps with offsets, merge keys, anchor
+identity. Every deliberate divergence is pinned by a test.
+
+## Design
+
+One parse, one bulk drain: the record array and string arena are
+read in two FFI calls, then a pure-Python walk over the unpacked
+records — the FFI tax is O(1) per document, never per event (the
+same seam yeptris-ruby rides). The 36-byte record layout is
+ABI-pinned in the C header and mirrored in `_ffi.py`.
+
+## Performance
+
+`python3 bench.py` — same-process comparison against PyYAML (pure)
+and CSafeLoader/CDumper (libyaml C extensions):
+
+- **load**: 28-39x PyYAML pure, 3.8-6.1x CSafeLoader
+- **dump**: ~1.7x PyYAML pure, ~2x behind CDumper (which walks the
+  tree entirely in C — a no-C-extension design's ceiling is the
+  Python walk itself; the tree raises through ONE
+  `yeptris_document_build` call)
+
+Both directions are O(chunks) in FFI calls: loads drain records in
+two calls, dumps build through one flat entry array.

yeptris-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yeptris"
+version = "0.1.0"
+description = "YAML for Python at libleptris speed — an FFI-based (no C extension) binding over libyeptris, PyYAML-compatible"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Ribose Inc.", email = "open.source@ribose.com" }]
+keywords = ["yaml", "parser", "libyaml", "pyyaml"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://github.com/leptris/yeptris"
+Source = "https://github.com/leptris/yeptris-py"
+
+[project.optional-dependencies]
+test = ["pytest", "pyyaml"]
+
+[tool.setuptools]
+packages = ["yeptris"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

yeptris-0.1.0/setup.cfg

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

yeptris-0.1.0/tests/test_dump.py

@@ -0,0 +1,107 @@
+"""Dumper: PyYAML-safe_dump parity, and dump->load round-trips."""
+
+import datetime as dt
+
+import pytest
+import yaml as pyyaml
+
+from yeptris import yaml as pyml
+
+
+def test_block_style_sorted_keys():
+    text = pyml.safe_dump({"b": 2, "a": 1})
+    assert text == "a: 1\nb: 2\n"
+    assert pyyaml.safe_load(text) == {"a": 1, "b": 2}
+
+
+def test_sequences_and_none():
+    text = pyml.safe_dump([1, "x", None, True, 3.5])
+    assert text == "- 1\n- x\n- null\n- true\n- 3.5\n"
+
+
+def test_resolvable_strings_get_quoted():
+    text = pyml.safe_dump({"a": "yes", "b": "42", "c": "1.5", "d": "~",
+                           "e": "2020-01-02", "f": "0x10"})
+    doc = pyml.safe_load(text)
+    assert doc == {"a": "yes", "b": "42", "c": "1.5", "d": "~",
+                   "e": "2020-01-02", "f": "0x10"}
+
+
+def test_indicator_strings_get_quoted():
+    doc = pyml.safe_load(pyml.safe_dump({
+        "a": "# comment-ish", "b": "k: v", "c": "- lead", "d": "tra ",
+        "e": "with: colon", "f": "a #b", "g": "@at", "h": "|pipe",
+    }))
+    assert doc["a"] == "# comment-ish"
+    assert doc["c"] == "- lead"
+    assert doc["d"] == "tra "
+    assert doc["f"] == "a #b"
+    assert doc["g"] == "@at"
+
+
+def test_merge_key_string_quoted():
+    # a literal "<<" key must not become a merge on reparse: the
+    # dumper quotes it, so the load comes back as a string key
+    doc = pyml.safe_load(pyml.safe_dump({"<<": 1}))
+    assert doc == {"<<": 1}
+
+
+def test_datetimes():
+    text = pyml.safe_dump({"t": dt.datetime(2020, 1, 2, 3, 4, 5),
+                           "d": dt.date(2020, 1, 2)})
+    doc = pyml.safe_load(text)
+    assert doc == {"t": dt.datetime(2020, 1, 2, 3, 4, 5),
+                   "d": dt.date(2020, 1, 2)}
+
+
+def test_floats():
+    doc = pyml.safe_load(pyml.safe_dump(
+        [0.1, -2.5e300, float("inf"), float("-inf")]))
+    assert doc[0] == 0.1
+    assert doc[1] == -2.5e300
+    assert doc[2] == float("inf")
+    assert doc[3] == float("-inf")
+
+
+def test_unicode():
+    doc = pyml.safe_load(pyml.safe_dump({"name": "héllo wörld"}))
+    assert doc == {"name": "héllo wörld"}
+
+
+def test_unsafe_type_rejected():
+    with pytest.raises(TypeError):
+        pyml.safe_dump(object())
+
+
+def test_deep_nesting_rejected_not_crashed():
+    with pytest.raises(Exception):
+        v = []
+        cur = v
+        for _ in range(2000):
+            nxt = []
+            cur.append(nxt)
+            cur = nxt
+        pyml.safe_dump(v)
+
+
+def test_stream_write():
+    import io
+    out = io.StringIO()
+    assert pyml.safe_dump({"a": 1}, out) is None
+    assert out.getvalue() == "a: 1\n"
+
+
+def test_roundtrip_against_pyyaml_random_documents():
+    # a pile of shapes; whatever we dump must load identically under
+    # BOTH loaders (we cannot emit YAML only we can read)
+    docs = [
+        {"lists": [[1], [2, [3]]], "maps": {"x": {"y": "z"}}},
+        {"empty_list": [], "empty_map": {}, "empty_str": ""},
+        ["nested", ["deeper", ["still"]]],
+        {"bools": [True, False], "none": None},
+        {"text": "line one\nline two\n"},
+    ]
+    for doc in docs:
+        text = pyml.safe_dump(doc)
+        assert pyml.safe_load(text) == doc
+        assert pyyaml.safe_load(text) == doc

yeptris-0.1.0/tests/test_load.py

@@ -0,0 +1,154 @@
+"""Loader semantics: differential against PyYAML where the two must
+agree, explicit pins where they diverge by design."""
+
+import datetime as dt
+import math
+
+import pytest
+import yaml as pyyaml
+
+import yeptris
+from yeptris import ParseError
+from yeptris import yaml as pyml
+
+
+AGREE_CASES = [
+    # (yaml, expected) — checked against BOTH yeptris and PyYAML
+    ("k: v", {"k": "v"}),
+    ("a: 1", {"a": 1}),
+    ("a: -42", {"a": -42}),
+    ("a: 1.5", {"a": 1.5}),
+    ("a: 1e3", {"a": "1e3"}),              # PyYAML: needs a dot -> str
+    ("a: 1.5e-3", {"a": 0.0015}),
+    ("a: 0x1F", {"a": 31}),
+    ("a: 0o17", {"a": "0o17"}),            # PyYAML 1.1 has no 0o form
+    ("a: 010", {"a": 8}),                  # PyYAML 1.1 leading-0 octal
+    ("a: 1_000", {"a": 1000}),
+    ("a: 0b1010", {"a": 10}),
+    ("a: yes", {"a": True}),
+    ("a: no", {"a": False}),
+    ("a: on", {"a": True}),
+    ("a: off", {"a": False}),
+    ("a: true", {"a": True}),
+    ("a: null", {"a": None}),
+    ("a: ~", {"a": None}),
+    ("a:", {"a": None}),
+    ("- 1\n- two\n- 3.5", [1, "two", 3.5]),
+    ("[]", []),
+    ("{}", {}),
+    ("{a: 1, b: [2, 3]}", {"a": 1, "b": [2, 3]}),
+    ("'42': quoted", {"42": "quoted"}),
+    ('"42": quoted', {"42": "quoted"}),
+    ("a: 'single'", {"a": "single"}),
+    ('a: "double #not comment"', {"a": "double #not comment"}),
+    ("a: |\n  line1\n  line2\n", {"a": "line1\nline2\n"}),
+    ("a: >\n  fold\n  ed\n", {"a": "fold ed\n"}),
+    ("a: .inf\nb: -.inf", {"a": math.inf, "b": -math.inf}),
+    ("a: 190:20:30", {"a": 685230}),        # sexagesimal int
+    ("a: 190:20:30.15", {"a": 685230.15}),  # sexagesimal float
+    ("&a [*a]", None),                      # self-ref -> handled separately
+]
+
+
+@pytest.mark.parametrize("text,expected", AGREE_CASES[:-1])
+def test_matches_pyyaml(text, expected):
+    ours = pyml.safe_load(text)
+    theirs = pyyaml.safe_load(text)
+    assert ours == expected
+    assert theirs == expected, f"PyYAML disagrees about the fixture itself: {theirs!r}"
+
+
+def test_self_referencing_alias():
+    ours = pyml.safe_load("&a [*a]")
+    theirs = pyyaml.safe_load("&a [*a]")
+    assert isinstance(ours, list)
+    assert ours[0] is ours          # identity preserved, like PyYAML
+    assert theirs[0] is theirs
+
+
+DIVERGENT = [
+    # (yaml, ours, pyyaml) — pinned, documented divergences
+    ("a: y", {"a": "y"}, {"a": "y"}),       # same outcome, different reason
+    ("a: 1:2:3", {"a": 3723}, {"a": 3723}), # both sexagesimal
+    ("a: 0o17", {"a": "0o17"}, {"a": "0o17"}),
+]
+
+
+def test_single_char_bool_words_stay_strings():
+    # Psych resolves y/n as bool; PyYAML does not. Ours follows
+    # PyYAML here (the Python reference), overriding the resolver's
+    # single-char bool verdicts.
+    assert pyml.safe_load("a: y") == {"a": "y"}
+    assert pyml.safe_load("a: n") == {"a": "n"}
+    assert pyml.safe_load("a: Y") == {"a": "Y"}
+    assert pyml.safe_load("a: yes") == {"a": True}
+
+
+def test_merge_keys():
+    ours = pyml.safe_load("a: 1\n<<: {b: 2}\n")
+    assert ours == {"a": 1, "b": 2}  # existing keys win
+    ours = pyml.safe_load("<<: [{a: 1, x: 0}, {b: 2, x: 9}]\n")
+    assert ours == {"a": 1, "x": 0, "b": 2}  # first merge wins
+
+
+def test_anchor_identity():
+    doc = pyml.safe_load("a: &x [1]\nb: *x\nc: &y {k: v}\nd: *y\n")
+    assert doc["a"] is doc["b"]
+    assert doc["c"] is doc["d"]
+
+
+def test_timestamps():
+    # differential: PyYAML's own construct_yaml_timestamp semantics
+    forms = [
+        "2001-12-14 21:59:43.10 -05:00",
+        "2001-12-14T21:59:43.10Z",
+        "2001-12-14 21:59:43.10",
+        "2001-12-14t21:59:43.10-05:00",
+        "2001-12-14",
+        "2001-12-14 21:59:43",
+    ]
+    for f in forms:
+        assert pyml.safe_load(f) == pyyaml.safe_load(f), f
+    assert pyml.safe_load("2001-12-14 21:59:43.10 -05:00").utcoffset() == \
+        dt.timedelta(hours=-5)
+    # a QUOTED date is a string (implicit-only host-side shaping)
+    assert pyml.safe_load('"2001-12-14"') == "2001-12-14"
+
+
+def test_special_floats():
+    doc = pyml.safe_load("a: .nan\nb: .inf\nc: -.Inf")
+    assert math.isnan(doc["a"])
+    assert doc["b"] == math.inf
+    assert doc["c"] == -math.inf
+
+
+def test_multidocument():
+    docs = list(pyml.safe_load_all("--- 1\n--- two\n---\n- 3\n"))
+    assert docs == [1, "two", [3]]
+    assert pyml.safe_load("--- 1\n--- 2\n") == 1
+
+
+def test_empty_stream():
+    assert pyml.safe_load("") is None
+    assert pyml.safe_load("# just a comment\n") is None
+    assert list(pyml.safe_load_all("")) == []
+
+
+def test_parse_error():
+    with pytest.raises(ParseError) as ei:
+        pyml.safe_load("a: [1, 2")
+    assert ei.value.line >= 1
+    with pytest.raises(ParseError):
+        pyml.safe_load("a: *undefined")
+
+
+def test_bytes_and_file_like():
+    import io
+    assert pyml.safe_load(b"k: v") == {"k": "v"}
+    assert pyml.safe_load(io.StringIO("k: v")) == {"k": "v"}
+    assert pyml.safe_load(io.BytesIO(b"k: v")) == {"k": "v"}
+
+
+def test_neutral_surface():
+    assert yeptris.load("k: v") == {"k": "v"}
+    assert list(yeptris.load_all("--- 1\n--- 2\n")) == [1, 2]

yeptris-0.1.0/yeptris/__init__.py

@@ -0,0 +1,17 @@
+"""yeptris — YAML for Python at libleptris speed.
+
+An FFI-based (no C extension) YAML library over libyeptris. The
+neutral surface lives here; `yeptris.yaml` carries the PyYAML-
+compatible one.
+"""
+
+from ._ffi import ParseError, YeptrisError
+from ._dumper import dump
+from ._loader import load, load_all
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "load", "load_all", "dump",
+    "YeptrisError", "ParseError", "__version__",
+]

yeptris-0.1.0/yeptris/_dumper.py

@@ -0,0 +1,179 @@
+"""Python values to YAML: one flat build spec, ONE FFI call.
+
+The dump-side mirror of the loader's bulk drain: the tree is walked
+into a flat entry array (document order — the same grammar as the
+event stream) plus one string blob; yeptris_document_build raises the
+DOM in a single call, and the emitter serializes it. Per-node FFI is
+gone: dump cost is O(chunks), like load.
+
+A string dumps PLAIN exactly when it would reparse as the same
+string under the loading schema — every resolvable word, number
+shape, and timestamp needs quotes.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import datetime as _dt
+
+from . import _ffi as F
+from ._loader import _to_float, _to_int, _to_timestamp
+
+# PyYAML's null/bool resolvers (case variants via lower())
+_NULL_WORDS = {"", "~", "null"}
+_BOOL_WORDS = {"y", "yes", "n", "no", "true", "false", "on", "off"}
+
+
+_SAFE_WORD = __import__("re").compile(r"^[A-Za-z][A-Za-z0-9_\-./ ]*$")
+
+
+def _plain_ok(text: str) -> bool:
+    # fast lane: a letter-started word of safe characters (spaces
+    # allowed, no trailing space — it would be eaten on reparse) can
+    # be no number, timestamp, or indicator shape; only the reserved
+    # words can still reshape, and the set lookups are cheap
+    if _SAFE_WORD.match(text) is not None and not text.endswith(" ") and \
+            text.lower() not in _NULL_WORDS and text.lower() not in _BOOL_WORDS:
+        return True
+    if text != text.strip() or not text:
+        return False
+    if "\n" in text or "\t" in text:
+        return False
+    first = text[0]
+    if first in "#,[]{}&*!|>'\"%@`":
+        return False
+    if first in "-?:" and (len(text) == 1 or text[1] in " \t"):
+        return False
+    if ": " in text or text.endswith(":") or " #" in text:
+        return False
+    if text == "<<":
+        return False
+    if text.lower() in _NULL_WORDS or text.lower() in _BOOL_WORDS:
+        return False
+    if _to_int(text) is not None or _to_float(text) is not None:
+        return False
+    if _to_timestamp(text) is not None:
+        return False
+    return True
+
+
+def _float_text(value: float) -> str:
+    if value != value:
+        return ".nan"
+    if value == float("inf"):
+        return ".inf"
+    if value == float("-inf"):
+        return "-.inf"
+    return repr(value)
+
+
+_MAX_DEPTH = 500
+
+
+def _entries(value, emit, blob, depth, sort_keys):
+    """Emits build entries (document order) and blob slices; returns
+    True on success, False on unsupported nesting depth. The scalar
+    arms are fully inlined — one function call per node was a
+    measurable fraction of the walk in CPython."""
+    if depth > _MAX_DEPTH:
+        return False
+
+    if value is None:
+        emit(F.BUILD_SCALAR, F.STYLE_PLAIN, len(blob), 4)
+        blob += b"null"
+    elif value is True:
+        emit(F.BUILD_SCALAR, F.STYLE_PLAIN, len(blob), 4)
+        blob += b"true"
+    elif value is False:
+        emit(F.BUILD_SCALAR, F.STYLE_PLAIN, len(blob), 5)
+        blob += b"false"
+    elif type(value) is int:
+        buf = str(value).encode()
+        emit(F.BUILD_SCALAR, F.STYLE_PLAIN, len(blob), len(buf))
+        blob += buf
+    elif type(value) is float:
+        buf = _float_text(value).encode()
+        emit(F.BUILD_SCALAR, F.STYLE_PLAIN, len(blob), len(buf))
+        blob += buf
+    elif type(value) is str:
+        buf = value.encode("utf-8")
+        emit(F.BUILD_SCALAR,
+             F.STYLE_PLAIN if _plain_ok(value) else F.STYLE_DOUBLE_QUOTED,
+             len(blob), len(buf))
+        blob += buf
+    elif isinstance(value, _dt.datetime):
+        buf = value.isoformat(sep=" ").encode()
+        emit(F.BUILD_SCALAR, F.STYLE_PLAIN, len(blob), len(buf))
+        blob += buf
+    elif isinstance(value, _dt.date):
+        buf = value.isoformat().encode()
+        emit(F.BUILD_SCALAR, F.STYLE_PLAIN, len(blob), len(buf))
+        blob += buf
+    elif isinstance(value, dict):
+        emit(F.BUILD_MAP, 0, 0, 0)
+        items = list(value.items())
+        if sort_keys:
+            try:
+                items.sort(key=lambda kv: (str(type(kv[0])), str(kv[0])))
+            except TypeError:
+                pass
+        for k, v in items:
+            # the host's plain-safety decides keys (a '<<' or
+            # resolvable-text key must not re-shape or merge on
+            # reparse — the C table cannot know the reading schema)
+            if not _entries(k, emit, blob, depth + 1, sort_keys):
+                return False
+            if not _entries(v, emit, blob, depth + 1, sort_keys):
+                return False
+        emit(F.BUILD_END, 0, 0, 0)
+    elif isinstance(value, (list, tuple)):
+        emit(F.BUILD_SEQ, 0, 0, 0)
+        for item in value:
+            if not _entries(item, emit, blob, depth + 1, sort_keys):
+                return False
+        emit(F.BUILD_END, 0, 0, 0)
+    elif isinstance(value, (set, frozenset)):
+        emit(F.BUILD_SEQ, 0, 0, 0)
+        for item in sorted(value, key=repr):
+            if not _entries(item, emit, blob, depth + 1, sort_keys):
+                return False
+        emit(F.BUILD_END, 0, 0, 0)
+    else:
+        raise TypeError(f"cannot dump {type(value).__name__!r} safely")
+    return True
+
+
+def dump(value, *, sort_keys: bool = True) -> str:
+    """Serialize one Python value as a single YAML document.
+
+    PyYAML safe_dump defaults: block style, keys sorted, unicode
+    allowed. Raises TypeError for types with no safe form.
+    """
+    parts = []
+    pack = F.BUILD_ENTRY.pack
+    blob = bytearray()
+    count = 0
+
+    def emit(op, style, off, ln):
+        nonlocal count
+        parts.append(pack(op, style, 0, off, ln))
+        count += 1
+
+    if not _entries(value, emit, blob, 0, sort_keys):
+        raise F.YeptrisError("dump: object nests too deeply")
+    doc = F._lib.yeptris_document_new()
+    if not doc:
+        raise F.YeptrisError("document allocation failed")
+    try:
+        rc = F._lib.yeptris_document_build(
+            doc, b"".join(parts), count, bytes(blob), len(blob)
+        )
+        if rc != F.OK:
+            raise F.YeptrisError(f"document_build failed: {rc}")
+        length = F._sz(0)
+        out = F._lib.yeptris_serialize(doc, ctypes.byref(length))
+        if not out:
+            raise F.YeptrisError("serialize failed")
+        return F.read_owned(out, length.value).decode("utf-8")
+    finally:
+        F._lib.yeptris_document_free(doc)

yeptris-0.1.0/yeptris/_ffi.py

@@ -0,0 +1,225 @@
+"""ctypes bindings to libyeptris — one signature, declared once.
+
+No C extension, no compile step: the shared library is dlopen'd the
+way the FFI gem does it for yeptris-ruby. Search order:
+  1. $YEPTRIS_LIB_PATH
+  2. a vendored yeptris/_platform/<tag>/libyeptris.* next to the package
+  3. a sibling C checkout's build directory (development)
+
+The event record layout (36 bytes) is ABI-pinned in the C header and
+mirrored here; `_RECORD` unpacks one record in a single call.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import struct
+import sys
+from pathlib import Path
+
+# YeptrisStatus (error.h)
+OK = 0
+ERROR_PARSE = 1
+ERROR_MEMORY = 2
+ERROR_DEPTH = 3
+ERROR_ENCODING = 4
+ERROR_IO = 5
+ERROR_ARG = 6
+ERROR_UNSUPPORTED = 7
+ERROR_INTERNAL = 8
+
+# YeptrisSchema (resolve.h)
+SCHEMA_12_CORE = 0
+SCHEMA_11_COMPAT = 1
+
+# YeptrisEventType (events.h)
+STREAM_START = 1
+STREAM_END = 2
+DOCUMENT_START = 3
+DOCUMENT_END = 4
+SEQUENCE_START = 5
+SEQUENCE_END = 6
+MAPPING_START = 7
+MAPPING_END = 8
+SCALAR = 9
+ALIAS = 10
+
+# YeptrisTagId (resolve.h)
+TAG_STR = 0
+TAG_INT = 1
+TAG_FLOAT = 2
+TAG_BOOL = 3
+TAG_NULL = 4
+TAG_TIMESTAMP = 5
+TAG_SEQ = 6
+TAG_MAP = 7
+TAG_BINARY = 8
+TAG_MERGE = 9
+TAG_VALUE = 10
+
+# YeptrisScalarStyle (dom.h)
+STYLE_PLAIN = 1
+STYLE_SINGLE_QUOTED = 2
+STYLE_DOUBLE_QUOTED = 3
+STYLE_LITERAL = 4
+STYLE_FOLDED = 5
+
+# YeptrisEventRecord: type, style, flags, tag_id (uint8 x4) then
+# line, col, value_off, value_len, anchor_off, anchor_len, tag_off,
+# tag_len (uint32 x8). sizeof == 36, ABI-pinned.
+_RECORD = struct.Struct("<4B8I")
+RECORD_SIZE = _RECORD.size
+assert RECORD_SIZE == 36
+
+# Flag bits (events.h)
+EF_FLOW = 1 << 0
+EF_EXPLICIT = 1 << 1
+EF_IMPLICIT = 1 << 2
+
+
+class YeptrisError(Exception):
+    """Base: something went wrong inside or around the library."""
+
+
+class ParseError(YeptrisError):
+    """Malformed YAML. Carries the 1-based line and column."""
+
+    def __init__(self, message: str, line: int = 0, column: int = 0):
+        super().__init__(f"{message} at line {line}, column {column}"
+                         if line else message)
+        self.line = line
+        self.column = column
+
+
+def _candidate_paths():
+    env = os.environ.get("YEPTRIS_LIB_PATH")
+    if env:
+        yield Path(env)
+    here = Path(__file__).resolve().parent
+    for p in sorted(here.glob("_platform/*/libyeptris.*")):
+        yield p
+    names = ["libyeptris.dylib", "libyeptris.so"]
+    for build in ("build", "build-validate"):
+        for name in names:
+            yield here.parent.parent / "yeptris" / build / "src" / name
+
+
+def _load_lib() -> ctypes.CDLL:
+    tried = []
+    for path in _candidate_paths():
+        try:
+            if path.exists():
+                return ctypes.CDLL(str(path))
+            tried.append(str(path))
+        except OSError:
+            tried.append(str(path))
+    raise YeptrisError(
+        "could not load the libyeptris library. Set YEPTRIS_LIB_PATH to a "
+        "libyeptris.{so,dylib,dll}, install a platform wheel, or build the "
+        "sibling C checkout. Tried: " + ", ".join(tried)
+    )
+
+
+_lib = _load_lib()
+
+_u8p = ctypes.POINTER(ctypes.c_char)
+_p = ctypes.c_void_p
+_sz = ctypes.c_size_t
+
+_lib.yeptris_recorder_new_ex.argtypes = [ctypes.c_int]
+_lib.yeptris_recorder_new_ex.restype = _p
+_lib.yeptris_recorder_feed.argtypes = [_p, ctypes.c_char_p, _sz, ctypes.c_int]
+_lib.yeptris_recorder_feed.restype = ctypes.c_int
+_lib.yeptris_recorder_records.argtypes = [_p, ctypes.POINTER(_sz)]
+_lib.yeptris_recorder_records.restype = _u8p
+_lib.yeptris_recorder_arena.argtypes = [_p, ctypes.POINTER(_sz)]
+_lib.yeptris_recorder_arena.restype = ctypes.c_char_p
+_lib.yeptris_recorder_free.argtypes = [_p]
+
+_lib.yeptris_last_error.argtypes = [ctypes.POINTER(ctypes.c_uint32),
+                                    ctypes.POINTER(ctypes.c_uint32)]
+_lib.yeptris_last_error.restype = ctypes.c_char_p
+
+_lib.yeptris_document_new.argtypes = []
+_lib.yeptris_document_new.restype = _p
+_lib.yeptris_document_free.argtypes = [_p]
+_lib.yeptris_document_set_root.argtypes = [_p, _p]
+_lib.yeptris_document_set_root.restype = ctypes.c_int
+_lib.yeptris_node_new_scalar.argtypes = [_p, ctypes.c_char_p, _sz, ctypes.c_int]
+_lib.yeptris_node_new_scalar.restype = _p
+_lib.yeptris_node_new_sequence.argtypes = [_p]
+_lib.yeptris_node_new_sequence.restype = _p
+_lib.yeptris_node_new_mapping.argtypes = [_p]
+_lib.yeptris_node_new_mapping.restype = _p
+_lib.yeptris_node_seq_add.argtypes = [_p, _p]
+_lib.yeptris_node_seq_add.restype = ctypes.c_int
+_lib.yeptris_node_map_add.argtypes = [_p, ctypes.c_char_p, _sz, _p]
+_lib.yeptris_node_map_add.restype = ctypes.c_int
+_lib.yeptris_node_map_add_node.argtypes = [_p, _p, _p]
+_lib.yeptris_node_map_add_node.restype = ctypes.c_int
+_lib.yeptris_document_build.argtypes = [_p, ctypes.c_void_p, _sz,
+                                        ctypes.c_char_p, _sz]
+_lib.yeptris_document_build.restype = ctypes.c_int
+
+# YeptrisBuildEntry: op, style, reserved, off, len — 12 bytes, pinned
+BUILD_ENTRY = struct.Struct("<BBHII")
+BUILD_SCALAR, BUILD_SEQ, BUILD_MAP, BUILD_END = 1, 2, 3, 4
+
+# restype c_void_p: the malloc'd buffer's pointer must stay a pointer
+# so it can be freed (c_char_p would auto-convert and leak it)
+_lib.yeptris_serialize.argtypes = [_p, ctypes.POINTER(_sz)]
+_lib.yeptris_serialize.restype = ctypes.c_void_p
+
+# serialize() returns a malloc'd buffer (caller frees, emit.h) — the
+# library allocates with the system allocator, so libc free is exact
+libc_free = ctypes.CDLL(None).free
+libc_free.argtypes = [ctypes.c_void_p]
+
+
+def last_error():
+    line = ctypes.c_uint32(0)
+    col = ctypes.c_uint32(0)
+    msg = _lib.yeptris_last_error(ctypes.byref(line), ctypes.byref(col))
+    return (msg.decode("utf-8", "replace") if msg else "parse error",
+            line.value, col.value)
+
+
+def free_buffer(buf) -> None:
+    if buf:
+        libc_free(ctypes.cast(buf, ctypes.c_void_p))
+
+
+def read_owned(ptr, length) -> bytes:
+    """The serialize* contract: caller copies then frees."""
+    if not ptr:
+        return b""
+    try:
+        return ctypes.string_at(ptr, length)
+    finally:
+        free_buffer(ptr)
+
+
+def drain(yaml: bytes, schema: int):
+    """One parse + one bulk read: the flat record array and the arena.
+
+    Returns (records_bytes, arena_bytes) — the FFI tax is O(1) per
+    parse, never per event (the same seam yeptris-ruby rides).
+    """
+    rec = _lib.yeptris_recorder_new_ex(schema)
+    if not rec:
+        raise YeptrisError("recorder allocation failed")
+    try:
+        st = _lib.yeptris_recorder_feed(rec, yaml, len(yaml), 1)
+        if st != OK:
+            msg, line, col = last_error()
+            raise ParseError(msg, line, col)
+        n = ctypes.c_size_t(0)
+        raw = _lib.yeptris_recorder_records(rec, ctypes.byref(n))
+        records = ctypes.string_at(raw, n.value * RECORD_SIZE) if n.value else b""
+        alen = ctypes.c_size_t(0)
+        arena_p = _lib.yeptris_recorder_arena(rec, ctypes.byref(alen))
+        arena = arena_p[:alen.value] if alen.value else b""
+        return records, arena
+    finally:
+        _lib.yeptris_recorder_free(rec)

yeptris-0.1.0/yeptris/_loader.py

@@ -0,0 +1,309 @@
+"""Bulk-drain loader: events to Python values.
+
+One drain (records + arena read once), then a pure-Python walk over
+the unpacked record array — no per-event FFI calls. Typing comes
+from the C resolver's tag_id (the typing SSOT); the conversion
+functions below mirror PyYAML's SafeLoader constructors exactly
+(float sexagesimal folds reversed digits; timestamps carry their
+offset as tzinfo; merge keys are resolver-driven, so a quoted '<<'
+is a literal key).
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import re
+
+from . import _ffi as F
+
+_RECORD = F._RECORD
+
+_BOOL_TRUE = {"yes", "true", "on"}
+_BOOL_FALSE = {"no", "false", "off"}
+
+_INT_DEC = re.compile(r"^[-+]?(0|[1-9][0-9_]*)$")
+_INT_HEX = re.compile(r"^[-+]?0x[0-9a-fA-F_]+$")
+_INT_OCT = re.compile(r"^[-+]?0[0-7_]+$")
+_INT_BIN = re.compile(r"^[-+]?0b[01_]+$")
+_INT_SEXAGESIMAL = re.compile(r"^[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+$")
+
+# PyYAML's float resolver: the dot is required and the exponent
+# carries a mandatory sign — "1e3" is a STRING
+_FLOAT = re.compile(
+    r"^[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?$"
+    r"|^\.[0-9_]+(?:[eE][-+][0-9]+)?$"
+    r"|^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$"
+)
+_FLOAT_INF = re.compile(r"^[-+]?\.(?:inf|Inf|INF)$")
+_FLOAT_NAN = re.compile(r"^\.(?:nan|NaN|NAN)$")
+
+# PyYAML's timestamp regexp (SafeConstructor.timestamp_regexp)
+_TIMESTAMP = re.compile(
+    r"""^(?P<year>[0-9][0-9][0-9][0-9])
+        -(?P<month>[0-9][0-9]?)
+        -(?P<day>[0-9][0-9]?)
+        (?:(?:[Tt]|[ \t]+)
+        (?P<hour>[0-9][0-9]?)
+        :(?P<minute>[0-9][0-9])
+        :(?P<second>[0-9][0-9])
+        (?:\.(?P<fraction>[0-9]*))?
+        (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+        (?::(?P<tz_minute>[0-9][0-9]))?))?)?$""",
+    re.VERBOSE,
+)
+
+
+def _to_int(text: str):
+    if _INT_DEC.match(text):
+        return int(text.replace("_", ""), 10)
+    if _INT_HEX.match(text):
+        return int(text.replace("_", ""), 16)
+    if _INT_OCT.match(text):
+        return int(text.replace("_", ""), 8)
+    if _INT_BIN.match(text):
+        return int(text.replace("_", ""), 2)
+    if _INT_SEXAGESIMAL.match(text):
+        sign = -1 if text[0] == "-" else 1
+        value = 0
+        for part in text.lstrip("+-").split(":"):
+            value = value * 60 + int(part.replace("_", ""))
+        return sign * value
+    return None
+
+
+def _to_float(text: str):
+    """PyYAML's construct_yaml_float, faithfully."""
+    t = text.replace("_", "").lower()
+    sign = -1 if t[0] == "-" else 1
+    if t[0] in "+-":
+        t = t[1:]
+    if t == ".inf":
+        return sign * float("inf")
+    if t == ".nan":
+        return float("nan")
+    if ":" in t:
+        # reversed digits, base 1, *= 60 — the fraction part rides
+        # its segment as a float
+        value = 0.0
+        base = 1.0
+        for part in reversed(t.split(":")):
+            value += float(part) * base
+            base *= 60
+        return sign * value
+    if _FLOAT.match(text):
+        return sign * float(t)
+    return None
+
+
+def _to_timestamp(text: str):
+    m = _TIMESTAMP.match(text)
+    if m is None:
+        return None
+    g = m.groupdict()
+    year, month, day = int(g["year"]), int(g["month"]), int(g["day"])
+    if not g["hour"]:
+        return _dt.date(year, month, day)
+    fraction = g["fraction"] or ""
+    micro = int(fraction[:6].ljust(6, "0")) if fraction else 0
+    tzinfo = None
+    if g["tz_sign"]:
+        delta = _dt.timedelta(hours=int(g["tz_hour"]),
+                              minutes=int(g["tz_minute"] or 0))
+        if g["tz_sign"] == "-":
+            delta = -delta
+        tzinfo = _dt.timezone(delta)
+    elif g["tz"] == "Z":
+        tzinfo = _dt.timezone.utc
+    return _dt.datetime(year, month, day, int(g["hour"]), int(g["minute"]),
+                        int(g["second"]), micro, tzinfo=tzinfo)
+
+
+def _value(value: bytes, tag_id: int, flags: int):
+    """A scalar's Python value: byte-level fast paths for the shapes
+    that dominate real documents (int()/float() accept bytes), the
+    full PyYAML-conversion layer for everything else."""
+    if tag_id == F.TAG_STR:
+        text = value.decode("utf-8")
+        if flags & F.EF_IMPLICIT:
+            # the C resolver tags only FULL timestamps (Psych's
+            # grammar); PyYAML also accepts date-only forms — a
+            # plain scalar shaped like a date becomes one here. The
+            # dumper quotes strings that would re-shape.
+            ts = _to_timestamp(text)
+            if ts is not None:
+                return ts
+        return text
+    if tag_id == F.TAG_INT:
+        # digits-only (with optional sign, no leading zero — PyYAML
+        # reads those as octal) is the overwhelming shape
+        body = value[1:] if value[:1] in (b"-", b"+") else value
+        if body.isdigit() and (body[:1] != b"0" or len(body) == 1):
+            return int(value)
+        text = value.decode("utf-8")
+        v = _to_int(text)
+        return text if v is None else v
+    if tag_id == F.TAG_NULL:
+        return None
+    if tag_id == F.TAG_FLOAT:
+        # the C tag follows the 1.1 grammar; PyYAML additionally
+        # requires the dot — with a dot and no sexagesimal ':' the
+        # C float() is exact
+        if b":" not in value and b"." in value:
+            try:
+                return float(value)
+            except ValueError:
+                pass
+        text = value.decode("utf-8")
+        v = _to_float(text)
+        return text if v is None else v
+    text = value.decode("utf-8")
+    if tag_id == F.TAG_BOOL:
+        # Psych resolves single-char y/n as bool; PyYAML does not —
+        # this binding follows PyYAML (the override yeptris-ruby
+        # documents for Psych parity)
+        if len(text) == 1:
+            return text
+        lowered = text.lower()
+        if lowered in _BOOL_TRUE:
+            return True
+        if lowered in _BOOL_FALSE:
+            return False
+        return text
+    if tag_id == F.TAG_TIMESTAMP:
+        v = _to_timestamp(text)
+        return text if v is None else v
+    return text
+
+
+def _merge(target: dict, source) -> None:
+    """'<<' merge: existing keys win; sequences merge in order."""
+    if isinstance(source, dict):
+        for k, v in source.items():
+            target.setdefault(k, v)
+    elif isinstance(source, list):
+        for item in source:
+            if isinstance(item, dict):
+                for k, v in item.items():
+                    target.setdefault(k, v)
+
+
+def load_all(yaml, schema: int = F.SCHEMA_11_COMPAT):
+    """Every document in the stream, in order."""
+    records, arena = F.drain(_as_bytes(yaml), schema)
+
+    docs: list = []
+    stack: list = []
+    pending_key: list = [None]   # key awaiting its value, per open map
+    pending_tag: list = [None]   # the key's tag_id (merge is tag-driven)
+    anchors: dict = {}
+    merge_targets: dict = {}     # id(fresh container) -> dict to merge into
+
+    # hot loop: C-level record iteration with the placement logic
+    # inlined (this walk is the bulk of load time; a function call
+    # per event is measurable in CPython)
+    for rec in _RECORD.iter_unpack(records):
+        etype = rec[0]
+        tag_id = rec[3]
+        if etype == F.SCALAR:
+            v_off, v_len = rec[6], rec[7]
+            value = arena[v_off:v_off + v_len] if v_len else b""
+            v = _value(value, tag_id, rec[2])
+            a_len = rec[9]
+            if a_len:
+                anchors[arena[rec[8]:rec[8] + a_len]] = v
+            if stack:
+                parent = stack[-1]
+                if type(parent) is list:
+                    parent.append(v)
+                else:
+                    key = pending_key[-1]
+                    if key is None:
+                        pending_key[-1] = v
+                        pending_tag[-1] = tag_id
+                    else:
+                        pending_key[-1] = None
+                        if tag_id == F.TAG_MERGE:
+                            if type(v) in (dict, list) and not v:
+                                merge_targets[id(v)] = parent
+                            else:
+                                _merge(parent, v)
+                        else:
+                            parent[key] = v
+            else:
+                docs[-1] = v
+        elif etype == F.MAPPING_START or etype == F.SEQUENCE_START:
+            fresh = {} if etype == F.MAPPING_START else []
+            a_len = rec[9]
+            if a_len:
+                anchors[arena[rec[8]:rec[8] + a_len]] = fresh
+            if stack:
+                parent = stack[-1]
+                if type(parent) is list:
+                    parent.append(fresh)
+                else:
+                    key = pending_key[-1]
+                    if key is None:
+                        pending_key[-1] = fresh
+                        pending_tag[-1] = F.TAG_STR
+                    else:
+                        pending_key[-1] = None
+                        if key == "<<" and pending_tag[-1] == F.TAG_MERGE and not fresh:
+                            merge_targets[id(fresh)] = parent
+                        else:
+                            parent[key] = fresh
+            else:
+                docs[-1] = fresh
+            stack.append(fresh)
+            pending_key.append(None)
+            pending_tag.append(None)
+        elif etype == F.MAPPING_END or etype == F.SEQUENCE_END:
+            closed = stack.pop()
+            pending_key.pop()
+            pending_tag.pop()
+            target = merge_targets.pop(id(closed), None)
+            if target is not None:
+                _merge(target, closed)
+        elif etype == F.DOCUMENT_START:
+            docs.append(None)
+        elif etype == F.ALIAS:
+            # the alias NAME lives in the value field (events.h)
+            rec_v_len = rec[7]
+            v = anchors.get(arena[rec[6]:rec[6] + rec_v_len] if rec_v_len else b"")
+            if stack:
+                parent = stack[-1]
+                if type(parent) is list:
+                    parent.append(v)
+                else:
+                    key = pending_key[-1]
+                    if key is None:
+                        pending_key[-1] = v
+                        pending_tag[-1] = F.TAG_STR
+                    else:
+                        pending_key[-1] = None
+                        if key == "<<" and pending_tag[-1] == F.TAG_MERGE:
+                            _merge(parent, v)
+                        else:
+                            parent[key] = v
+            else:
+                docs[-1] = v
+    return docs
+
+
+def _as_bytes(yaml) -> bytes:
+    if isinstance(yaml, (bytes, bytearray)):
+        return bytes(yaml)
+    if isinstance(yaml, str):
+        return yaml.encode("utf-8")
+    read = getattr(yaml, "read", None)
+    if read is None:
+        raise TypeError("expected str, bytes, or a file-like object")
+    data = read()
+    if isinstance(data, str):
+        return data.encode("utf-8")
+    return bytes(data)
+
+
+def load(yaml, schema: int = F.SCHEMA_11_COMPAT):
+    """The first document of the stream, or None when empty."""
+    docs = load_all(yaml, schema)
+    return docs[0] if docs else None

yeptris-0.1.0/yeptris/yaml.py

@@ -0,0 +1,36 @@
+"""The PyYAML-compatible surface: safe_load / safe_load_all / safe_dump.
+
+Semantics target PyYAML's SafeLoader/SafeDumper (YAML 1.1 implicit
+typing, timestamps, merge keys); the differential tests pin every
+divergence explicitly. `import yeptris.yaml as yaml` and existing
+code that calls yaml.safe_load keeps working.
+"""
+
+from ._dumper import dump as _dump
+from ._loader import load_all as _load_all
+
+__all__ = ["safe_load", "safe_load_all", "safe_dump", "load", "dump"]
+
+
+def safe_load(stream):
+    """First document of the stream (None when empty)."""
+    docs = _load_all(stream)
+    return docs[0] if docs else None
+
+
+def safe_load_all(stream):
+    """Every document in the stream, in order."""
+    return _load_all(stream)
+
+
+def safe_dump(data, stream=None, *, sort_keys=True, **_ignored):
+    """Serialize as one YAML document (PyYAML safe_dump defaults)."""
+    text = _dump(data, sort_keys=sort_keys)
+    if stream is None:
+        return text
+    stream.write(text)
+    return None
+
+
+load = safe_load
+dump = safe_dump

yeptris-0.1.0/yeptris.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: yeptris
+Version: 0.1.0
+Summary: YAML for Python at libleptris speed — an FFI-based (no C extension) binding over libyeptris, PyYAML-compatible
+Author-email: "Ribose Inc." <open.source@ribose.com>
+License: MIT
+Project-URL: Homepage, https://github.com/leptris/yeptris
+Project-URL: Source, https://github.com/leptris/yeptris-py
+Keywords: yaml,parser,libyaml,pyyaml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pyyaml; extra == "test"
+
+# yeptris — YAML for Python at libleptris speed
+
+An FFI-based (no C extension) YAML library over
+[libyeptris](https://github.com/leptris/yeptris) — the YAML
+counterpart of libleptris. PyYAML-compatible semantics, one shared
+library, zero compilation at install.
+
+## Install (development)
+
+```sh
+# the sibling C checkout: ~/src/leptris/yeptris
+cmake -B build -S . -DCMAKE_BUILD_TYPE=Release -DYEPTRIS_BUILD_SHARED=ON
+cmake --build build
+
+cd ~/src/leptris/yeptris-py
+YEPTRIS_LIB_PATH=../yeptris/build/src/libyeptris.dylib python3 -m pytest
+```
+
+Without `YEPTRIS_LIB_PATH` the loader falls back to a vendored
+`yeptris/_platform/<tag>/` copy, then to the sibling checkout's
+build directory. Any `libyeptris.{so,dylib,dll}` path works.
+
+## Usage
+
+```python
+import yeptris
+from yeptris import yaml  # PyYAML-compatible surface
+
+yaml.safe_load("name: yeptris\nrating: 10\n")
+# {'name': 'yeptris', 'rating': 10}
+
+yaml.safe_load_all("--- 1\n--- two\n")   # [1, 'two']
+yaml.safe_dump({"b": 2, "a": [1, "x"]})  # 'a:\n  - 1\n  - x\nb: 2\n'
+
+yeptris.load("k: v")        # the neutral surface
+yeptris.dump({"k": [1, 2]})
+```
+
+Typing follows PyYAML's SafeLoader (YAML 1.1 implicit typing):
+`yes/no/on/off` booleans, `0x`/leading-0/`0b`/sexagesimal integers,
+dot-required floats, timestamps with offsets, merge keys, anchor
+identity. Every deliberate divergence is pinned by a test.
+
+## Design
+
+One parse, one bulk drain: the record array and string arena are
+read in two FFI calls, then a pure-Python walk over the unpacked
+records — the FFI tax is O(1) per document, never per event (the
+same seam yeptris-ruby rides). The 36-byte record layout is
+ABI-pinned in the C header and mirrored in `_ffi.py`.
+
+## Performance
+
+`python3 bench.py` — same-process comparison against PyYAML (pure)
+and CSafeLoader/CDumper (libyaml C extensions):
+
+- **load**: 28-39x PyYAML pure, 3.8-6.1x CSafeLoader
+- **dump**: ~1.7x PyYAML pure, ~2x behind CDumper (which walks the
+  tree entirely in C — a no-C-extension design's ceiling is the
+  Python walk itself; the tree raises through ONE
+  `yeptris_document_build` call)
+
+Both directions are O(chunks) in FFI calls: loads drain records in
+two calls, dumps build through one flat entry array.

yeptris-0.1.0/yeptris.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+tests/test_dump.py
+tests/test_load.py
+yeptris/__init__.py
+yeptris/_dumper.py
+yeptris/_ffi.py
+yeptris/_loader.py
+yeptris/yaml.py
+yeptris.egg-info/PKG-INFO
+yeptris.egg-info/SOURCES.txt
+yeptris.egg-info/dependency_links.txt
+yeptris.egg-info/requires.txt
+yeptris.egg-info/top_level.txt

yeptris-0.1.0/yeptris.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yeptris-0.1.0/yeptris.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[test]
+pytest
+pyyaml

yeptris-0.1.0/yeptris.egg-info/top_level.txt

@@ -0,0 +1 @@
+yeptris