teptris 0.2.15__tar.gz

teptris-0.2.15/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 teptris contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

teptris-0.2.15/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include vendor *.c *.h *.md

teptris-0.2.15/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: teptris
+Version: 0.2.15
+Summary: TOML for Python at libteptris speed (native C extension, no fallback)
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# teptris-py — TOML for Python at libleptris speed
+
+A native C-extension binding (no ctypes, no fallback) over
+[libteptris](https://github.com/leptris/teptris) — the TOML counterpart
+of leptris-py (XML) and yeptris-py (YAML). API shape mirrors
+`tomllib`/`tomli` (`loads`/`load` raising `TOMLDecodeError`) plus a
+`dumps` writer in the `tomli_w` spirit. Datetime mapping mirrors
+tomllib: aware/naive `datetime`, `date`, `time`.
+
+Both directions are native: `dumps` walks the object tree in C
+through the builder API and emits via the shared engine emitter —
+3.5×–14.2× faster than tomli_w on every benchmark shape. The engine
+implements the TOML 1.1 draft grammar (a strict superset of 1.0)
+with 100% toml-test conformance, and parses at ≥3× the best C/C++
+competitor on every shape.
+
+## Packaging
+
+`pip install teptris` resolves one of 8 `cp39-abi3` wheels —
+manylinux/musllinux x86_64 and aarch64, macOS arm64 and x86_64,
+Windows AMD64 and ARM64 — covering every CPython >= 3.9 including
+future minors. The extension statically links `libteptris`, so each
+wheel is a single self-contained module (no shared-library chain).
+Linux wheels build the engine inside each container via cibuildwheel
+so musllinux links musl; the manylinux wheels carry the maximal tag
+set (glibc >= 2.17).
+
+Every other platform (FreeBSD, Solaris/illumos, any CPython on an
+exotic arch) installs the sdist, which vendors the engine and
+compiles it with the installing interpreter's compiler — a C compiler
+is required, and the build fails loudly without one.
+
+## Development
+
+`setup.py` links the engine statically when it finds
+`libteptris.a`/`teptris.lib` under `TEPTRIS_LIBDIR` (what the wheels
+ship); otherwise it falls back to the shared library with an rpath to
+its build tree. Point `TEPTRIS_INCLUDE`/`TEPTRIS_LIBDIR` at a C
+checkout's build and run the suite:
+
+```sh
+cmake -B ../teptris/build -S ../teptris \
+    -DCMAKE_BUILD_TYPE=Release -DTEPTRIS_BUILD_SHARED=OFF -DTEPTRIS_BUILD_STATIC=ON
+cmake --build ../teptris/build
+TEPTRIS_INCLUDE=../teptris/src/include TEPTRIS_LIBDIR=../teptris/build/src \
+    python3 setup.py build_ext --inplace
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+```
+
+Publishing and version numbers are USER release decisions.

teptris-0.2.15/README.md

@@ -0,0 +1,50 @@
+# teptris-py — TOML for Python at libleptris speed
+
+A native C-extension binding (no ctypes, no fallback) over
+[libteptris](https://github.com/leptris/teptris) — the TOML counterpart
+of leptris-py (XML) and yeptris-py (YAML). API shape mirrors
+`tomllib`/`tomli` (`loads`/`load` raising `TOMLDecodeError`) plus a
+`dumps` writer in the `tomli_w` spirit. Datetime mapping mirrors
+tomllib: aware/naive `datetime`, `date`, `time`.
+
+Both directions are native: `dumps` walks the object tree in C
+through the builder API and emits via the shared engine emitter —
+3.5×–14.2× faster than tomli_w on every benchmark shape. The engine
+implements the TOML 1.1 draft grammar (a strict superset of 1.0)
+with 100% toml-test conformance, and parses at ≥3× the best C/C++
+competitor on every shape.
+
+## Packaging
+
+`pip install teptris` resolves one of 8 `cp39-abi3` wheels —
+manylinux/musllinux x86_64 and aarch64, macOS arm64 and x86_64,
+Windows AMD64 and ARM64 — covering every CPython >= 3.9 including
+future minors. The extension statically links `libteptris`, so each
+wheel is a single self-contained module (no shared-library chain).
+Linux wheels build the engine inside each container via cibuildwheel
+so musllinux links musl; the manylinux wheels carry the maximal tag
+set (glibc >= 2.17).
+
+Every other platform (FreeBSD, Solaris/illumos, any CPython on an
+exotic arch) installs the sdist, which vendors the engine and
+compiles it with the installing interpreter's compiler — a C compiler
+is required, and the build fails loudly without one.
+
+## Development
+
+`setup.py` links the engine statically when it finds
+`libteptris.a`/`teptris.lib` under `TEPTRIS_LIBDIR` (what the wheels
+ship); otherwise it falls back to the shared library with an rpath to
+its build tree. Point `TEPTRIS_INCLUDE`/`TEPTRIS_LIBDIR` at a C
+checkout's build and run the suite:
+
+```sh
+cmake -B ../teptris/build -S ../teptris \
+    -DCMAKE_BUILD_TYPE=Release -DTEPTRIS_BUILD_SHARED=OFF -DTEPTRIS_BUILD_STATIC=ON
+cmake --build ../teptris/build
+TEPTRIS_INCLUDE=../teptris/src/include TEPTRIS_LIBDIR=../teptris/build/src \
+    python3 setup.py build_ext --inplace
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+```
+
+Publishing and version numbers are USER release decisions.

teptris-0.2.15/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "teptris"
+version = "0.2.15"
+description = "TOML for Python at libteptris speed (native C extension, no fallback)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+teptris = ["_platform/**/*", "*.so", "*.so.*", "*.dylib", "*.dylib.*", "*.dll"]

teptris-0.2.15/setup.cfg

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

teptris-0.2.15/setup.py

@@ -0,0 +1,68 @@
+import glob
+import os
+import sys
+from setuptools import setup, Extension
+
+# Vendored engine (sdist builds): when the C tree sits at vendor/,
+# compile it straight into the extension with the installing
+# interpreter's compiler — no cmake, no prebuilt archive. Precedence
+# over the archive path so a coincidental sibling teptris checkout
+# can never hijack an sdist install.
+_vendor = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                       "vendor", "libteptris")
+_engine_src = sorted(
+    glob.glob(os.path.join(_vendor, "src", "teptris", "**", "*.c"),
+              recursive=True))
+
+inc = os.environ.get("TEPTRIS_INCLUDE", "../teptris/src/include")
+libdir = os.environ.get("TEPTRIS_LIBDIR", "../teptris/build-shared/src")
+
+# Static-first: one self-contained _native module — no soname/DLL
+# chain to ship, relocate, or repair (the teptris-ruby #38 lesson,
+# applied to wheels so auditwheel/cibuildwheel can work with a plain
+# extension). Falls back to the shared lib for local dev trees.
+_archive = os.path.join(
+    libdir, "teptris.lib" if sys.platform == "win32" else "libteptris.a"
+)
+if _engine_src:
+    ext = Extension(
+        "teptris._native",
+        sources=["src/teptris/_native.c"] + _engine_src,
+        include_dirs=[os.path.join(_vendor, "src"),
+                      os.path.join(_vendor, "src", "include")],
+        py_limited_api=True,
+    )
+elif os.path.exists(_archive):
+    ext = Extension(
+        "teptris._native",
+        sources=["src/teptris/_native.c"],
+        include_dirs=[inc],
+        py_limited_api=True,
+        extra_objects=[_archive],
+    )
+else:
+    # @loader_path is Mach-O; ELF spells it $ORIGIN; PE has neither —
+    # the DLL ships beside the .pyd and CPython 3.8+ loads it via
+    # LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
+    ext = Extension(
+        "teptris._native",
+        sources=["src/teptris/_native.c"],
+        include_dirs=[inc],
+        py_limited_api=True,
+        library_dirs=[libdir],
+        libraries=["teptris"],
+        extra_link_args=(
+            []
+            if sys.platform == "win32"
+            else [
+                "-Wl,-rpath,"
+                + ("@loader_path" if sys.platform == "darwin" else "$ORIGIN")
+            ]
+        ),
+    )
+# package_dir spelled here too: raw `setup.py build_ext --inplace`
+# (which the wheel workflow runs) doesn't apply the pyproject
+# src-layout on older setuptools (3.8 cells resolved one), and then
+# the inplace copy targets teptris/ instead of src/teptris/.
+setup(ext_modules=[ext], package_dir={"": "src"},
+      options={"bdist_wheel": {"py_limited_api": "cp39"}})

teptris-0.2.15/src/teptris/__init__.py

@@ -0,0 +1,38 @@
+"""teptris — TOML for Python at libleptris speed.
+
+Native extension over libteptris (C11 TOML 1.1 grammar), no fallback. API shape
+mirrors tomllib/tomli: loads(str|bytes) -> dict raising TOMLDecodeError;
+dumps(obj) -> str in the tomli_w spirit. Datetime mapping mirrors
+tomllib: aware/naive datetime, date, time.
+"""
+from ._native import loads as _loads
+from ._native import dumps
+from ._native import DecodeError as _DecodeError
+
+
+class TOMLDecodeError(_DecodeError, ValueError):
+    pass
+
+
+def loads(data):
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    elif not isinstance(data, (bytes, bytearray)):
+        raise TypeError("loads() expects str or bytes")
+    try:
+        return _loads(bytes(data))
+    except _DecodeError as e:
+        err = TOMLDecodeError(str(e))
+        err.line = getattr(e, "line", 0)
+        err.column = getattr(e, "column", 0)
+        raise err from None
+
+
+def load(fp):
+    if hasattr(fp, "read"):
+        return loads(fp.read())
+    with open(fp, "rb") as f:
+        return loads(f.read())
+
+
+__all__ = ["TOMLDecodeError", "dumps", "load", "loads"]

teptris-0.2.15/src/teptris/_native.c

@@ -0,0 +1,382 @@
+#define PY_SSIZE_T_CLEAN
+#ifndef Py_LIMITED_API
+/* abi3 (#20): the datetime C-API is not in the limited API, so all
+ * datetime work goes through cached callables/attributes instead */
+#define Py_LIMITED_API 0x03090000
+#endif
+#include <Python.h>
+#include "teptris/teptris.h"
+
+static PyObject *TomlDecodeError;
+/* datetime module callables (limited API: the C-API is unavailable) */
+static PyObject *tep_dt_datetime, *tep_dt_date, *tep_dt_time,
+    *tep_dt_timedelta, *tep_dt_timezone;
+
+/* strong-ref attr read as long; def on missing/invalid (datetime
+ * attributes always exist on well-formed instances) */
+static long attr_long(PyObject *v, const char *name) {
+    PyObject *a = PyObject_GetAttrString(v, name);
+    if (a == NULL) { PyErr_Clear(); return 0; }
+    long r = PyLong_AsLong(a);
+    Py_DECREF(a);
+    if (r == -1 && PyErr_Occurred()) { PyErr_Clear(); return 0; }
+    return r;
+}
+
+static PyObject *obj_from_node(const teptris_node *n) {
+    switch (teptris_node_kind(n)) {
+    case TEPTRIS_TABLE: {
+        size_t len = teptris_node_table_length(n);
+        PyObject *h = PyDict_New();
+        if (!h) return NULL;
+        for (size_t i = 0; i < len; i++) {
+            teptris_view key;
+            const teptris_node *v = teptris_node_table_at(n, i, &key);
+            PyObject *k = PyUnicode_DecodeUTF8(key.ptr, (Py_ssize_t)key.len, "replace");
+            if (!k) { Py_DECREF(h); return NULL; }
+            PyObject *val = obj_from_node(v);
+            if (!val) { Py_DECREF(k); Py_DECREF(h); return NULL; }
+            int rc = PyDict_SetItem(h, k, val);
+            Py_DECREF(k); Py_DECREF(val);
+            if (rc < 0) { Py_DECREF(h); return NULL; }
+        }
+        return h;
+    }
+    case TEPTRIS_ARRAY: {
+        size_t len = teptris_node_array_length(n);
+        PyObject *a = PyList_New((Py_ssize_t)len);
+        if (!a) return NULL;
+        for (size_t i = 0; i < len; i++) {
+            PyObject *v = obj_from_node(teptris_node_array_at(n, i));
+            if (!v) { Py_DECREF(a); return NULL; }
+            /* SetItem steals v on both success and failure */
+            if (PyList_SetItem(a, (Py_ssize_t)i, v) < 0) {
+                Py_DECREF(a); return NULL;
+            }
+        }
+        return a;
+    }
+    case TEPTRIS_STRING: {
+        teptris_view s;
+        teptris_node_string(n, &s);
+        return PyUnicode_DecodeUTF8(s.ptr, (Py_ssize_t)s.len, "replace");
+    }
+    case TEPTRIS_INTEGER: {
+        int64_t v = 0; teptris_node_integer(n, &v);
+        return PyLong_FromLongLong(v);
+    }
+    case TEPTRIS_FLOAT: {
+        double v = 0; teptris_node_float(n, &v);
+        return PyFloat_FromDouble(v);
+    }
+    case TEPTRIS_BOOLEAN: {
+        bool v = false; teptris_node_boolean(n, &v);
+        return PyBool_FromLong(v ? 1 : 0);
+    }
+    default: {
+        teptris_datetime d; teptris_node_datetime(n, &d);
+        switch (teptris_node_kind(n)) {
+        case TEPTRIS_DATE_LOCAL:
+            return PyObject_CallFunctionObjArgs(
+                tep_dt_date, PyLong_FromLong(d.year), PyLong_FromLong(d.month),
+                PyLong_FromLong(d.day), NULL);
+        case TEPTRIS_TIME_LOCAL:
+            return PyObject_CallFunctionObjArgs(
+                tep_dt_time, PyLong_FromLong(d.hour),
+                PyLong_FromLong(d.minute), PyLong_FromLong(d.second),
+                PyLong_FromLong((long)(d.nanosecond / 1000)), NULL);
+        default: {
+            PyObject *us = PyLong_FromLong((long)(d.nanosecond / 1000));
+            if (!us) return NULL;
+            if (teptris_node_kind(n) == TEPTRIS_DATETIME_LOCAL)
+                return PyObject_CallFunctionObjArgs(
+                    tep_dt_datetime, PyLong_FromLong(d.year),
+                    PyLong_FromLong(d.month), PyLong_FromLong(d.day),
+                    PyLong_FromLong(d.hour), PyLong_FromLong(d.minute),
+                    PyLong_FromLong(d.second), us, NULL);
+            Py_DECREF(us);
+            /* aware: tz = timezone(timedelta(0, off)); datetime(..., tz) */
+            PyObject *delta = PyObject_CallFunctionObjArgs(
+                tep_dt_timedelta, PyLong_FromLong(0),
+                PyLong_FromLong((long)d.offset_seconds), PyLong_FromLong(0),
+                NULL);
+            if (!delta) return NULL;
+            PyObject *tz = PyObject_CallFunctionObjArgs(
+                tep_dt_timezone, delta, NULL);
+            Py_DECREF(delta);
+            if (!tz) return NULL;
+            PyObject *aware = PyObject_CallFunctionObjArgs(
+                tep_dt_datetime, PyLong_FromLong(d.year),
+                PyLong_FromLong(d.month), PyLong_FromLong(d.day),
+                PyLong_FromLong(d.hour), PyLong_FromLong(d.minute),
+                PyLong_FromLong(d.second),
+                PyLong_FromLong((long)(d.nanosecond / 1000)), tz, NULL);
+            Py_DECREF(tz);
+            return aware;
+        }}
+    }}
+}
+
+static PyObject *ext_load(PyObject *self, PyObject *args) {
+    (void)self;
+    PyObject *obj;
+    if (!PyArg_ParseTuple(args, "O", &obj)) return NULL;
+    const char *data = NULL;
+    Py_ssize_t len = 0;
+    PyObject *keepalive = NULL;
+    if (PyUnicode_Check(obj)) {
+        keepalive = PyUnicode_AsUTF8String(obj);
+        if (!keepalive) return NULL;
+        data = PyBytes_AsString(keepalive);
+        len = PyBytes_Size(keepalive);
+    } else if (PyBytes_Check(obj)) {
+        data = PyBytes_AsString(obj);
+        len = PyBytes_Size(obj);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "loads() expects str or bytes");
+        return NULL;
+    }
+    teptris_document *doc = NULL;
+    teptris_status st = teptris_parse(data, (size_t)len, NULL, &doc);
+    Py_XDECREF(keepalive);
+    if (st != TEPTRIS_OK) {
+        const teptris_error *e = teptris_document_error(doc);
+        PyObject *ex = PyObject_CallFunction(TomlDecodeError, "s", e->message);
+        teptris_document_free(doc);
+        if (ex) {
+            PyObject_SetAttrString(ex, "line", PyLong_FromSize_t(e->line));
+            PyObject_SetAttrString(ex, "column", PyLong_FromSize_t(e->column));
+            PyErr_SetObject(TomlDecodeError, ex);
+        }
+        return NULL;
+    }
+    PyObject *out = obj_from_node(teptris_document_root(doc));
+    teptris_document_free(doc);
+    return out;
+}
+
+
+/* ------------------------------------------------------------------ dump */
+
+static int build_table(teptris_builder *b, PyObject *obj);
+
+/* limited API: attribute reads only */
+static PyObject *dt_tzinfo(PyObject *v) {
+    return PyObject_GetAttrString(v, "tzinfo");
+}
+
+static int dump_check(teptris_status st) {
+    if (st == TEPTRIS_OK) return 0;
+    if (st == TEPTRIS_ERR_ALLOC) { PyErr_NoMemory(); return -1; }
+    PyErr_SetString(PyExc_TypeError, teptris_status_string(st));
+    return -1;
+}
+
+/* keyed scalar; key == NULL means array element */
+static int put_scalar(teptris_builder *b, const char *key, size_t klen,
+                      PyObject *v) {
+    if (PyBool_Check(v)) {
+        return dump_check(teptris_builder_put_boolean(b, key, klen,
+                                                      v == Py_True));
+    }
+    if (PyLong_Check(v)) {
+        long long i = PyLong_AsLongLong(v);
+        if (i == -1 && PyErr_Occurred()) return -1;
+        return dump_check(teptris_builder_put_integer(b, key, klen, i));
+    }
+    if (PyFloat_Check(v)) {
+        return dump_check(teptris_builder_put_float(
+            b, key, klen, PyFloat_AsDouble(v)));
+    }
+    if (PyUnicode_Check(v)) {
+        PyObject *kb = PyUnicode_AsUTF8String(v);
+        if (!kb) return -1;
+        int rc = dump_check(teptris_builder_put_string(
+            b, key, klen, PyBytes_AsString(kb), (size_t)PyBytes_Size(kb)));
+        Py_DECREF(kb);
+        return rc;
+    }
+    /* datetime first: datetime subclasses date */
+    if (PyObject_TypeCheck(v, (PyTypeObject *)tep_dt_datetime)) {
+        teptris_datetime dt;
+        memset(&dt, 0, sizeof(dt));
+        dt.year = (int32_t)attr_long(v, "year");
+        dt.month = (uint8_t)attr_long(v, "month");
+        dt.day = (uint8_t)attr_long(v, "day");
+        dt.hour = (uint8_t)attr_long(v, "hour");
+        dt.minute = (uint8_t)attr_long(v, "minute");
+        dt.second = (uint8_t)attr_long(v, "second");
+        dt.nanosecond = (uint32_t)attr_long(v, "microsecond") * 1000u;
+        PyObject *tz = dt_tzinfo(v);
+        if (tz == Py_None) {
+            Py_DECREF(tz);
+            return dump_check(teptris_builder_put_datetime(
+                b, key, klen, TEPTRIS_DATETIME_LOCAL, &dt));
+        }
+        PyObject *off = PyObject_CallMethod(tz, "utcoffset", "O", v);
+        Py_DECREF(tz);
+        if (!off) return -1;
+        if (off != Py_None) {
+            dt.offset_seconds =
+                attr_long(off, "days") * 86400 +
+                attr_long(off, "seconds");
+        }
+        Py_DECREF(off);
+        return dump_check(teptris_builder_put_datetime(
+            b, key, klen, TEPTRIS_DATETIME_OFFSET, &dt));
+    }
+    if (PyObject_TypeCheck(v, (PyTypeObject *)tep_dt_date)) {
+        teptris_datetime dt;
+        memset(&dt, 0, sizeof(dt));
+        dt.year = (int32_t)attr_long(v, "year");
+        dt.month = (uint8_t)attr_long(v, "month");
+        dt.day = (uint8_t)attr_long(v, "day");
+        return dump_check(teptris_builder_put_datetime(
+            b, key, klen, TEPTRIS_DATE_LOCAL, &dt));
+    }
+    if (PyObject_TypeCheck(v, (PyTypeObject *)tep_dt_time)) {
+        teptris_datetime dt;
+        memset(&dt, 0, sizeof(dt));
+        dt.hour = (uint8_t)attr_long(v, "hour");
+        dt.minute = (uint8_t)attr_long(v, "minute");
+        dt.second = (uint8_t)attr_long(v, "second");
+        dt.nanosecond = (uint32_t)attr_long(v, "microsecond") * 1000u;
+        return dump_check(teptris_builder_put_datetime(
+            b, key, klen, TEPTRIS_TIME_LOCAL, &dt));
+    }
+    PyErr_Format(PyExc_TypeError, "cannot dump %.200R",
+                 (PyObject *)Py_TYPE(v));
+    return -1;
+}
+
+/* element position: dict -> table element, list -> nested array */
+static int build_value(teptris_builder *b, PyObject *v) {
+    if (Py_EnterRecursiveCall(" while dumping a value")) return -1;
+    int rc;
+    if (PyDict_Check(v)) {
+        rc = dump_check(teptris_builder_open_table(b, NULL, 0));
+        if (rc == 0) rc = build_table(b, v);
+        if (rc == 0) rc = dump_check(teptris_builder_close(b));
+    } else if (PyList_Check(v)) {
+        rc = dump_check(teptris_builder_open_array(b, NULL, 0));
+        Py_ssize_t n = PyList_Size(v);
+        for (Py_ssize_t i = 0; rc == 0 && i < n; i++) {
+            rc = build_value(b, PyList_GetItem(v, i));
+        }
+        if (rc == 0) rc = dump_check(teptris_builder_close(b));
+    } else {
+        rc = put_scalar(b, NULL, 0, v);
+    }
+    Py_LeaveRecursiveCall();
+    return rc;
+}
+
+/* table position: keyed members */
+static int build_table(teptris_builder *b, PyObject *obj) {
+    if (Py_EnterRecursiveCall(" while dumping a table")) return -1;
+    PyObject *k, *v;
+    Py_ssize_t pos = 0;
+    int rc = 0;
+    while (rc == 0 && PyDict_Next(obj, &pos, &k, &v)) {
+        if (!PyUnicode_Check(k)) {
+            PyErr_SetString(PyExc_TypeError, "keys must be strings");
+            rc = -1;
+            break;
+        }
+        PyObject *kb = PyUnicode_AsUTF8String(k);
+        if (!kb) { rc = -1; break; }
+        const char *ks = PyBytes_AsString(kb);
+        size_t klen = (size_t)PyBytes_Size(kb);
+        if (PyDict_Check(v)) {
+            rc = dump_check(teptris_builder_open_table(b, ks, klen));
+            if (rc == 0) rc = build_table(b, v);
+            if (rc == 0) rc = dump_check(teptris_builder_close(b));
+        } else if (PyList_Check(v)) {
+            Py_ssize_t n = PyList_Size(v);
+            bool all_dict = n > 0;
+            for (Py_ssize_t i = 0; i < n; i++) {
+                if (!PyDict_Check(PyList_GetItem(v, i))) {
+                    all_dict = false;
+                    break;
+                }
+            }
+            rc = dump_check(all_dict
+                ? teptris_builder_open_array(b, ks, klen)
+                : teptris_builder_open_inline_array(b, ks, klen));
+            for (Py_ssize_t i = 0; rc == 0 && i < n; i++) {
+                rc = build_value(b, PyList_GetItem(v, i));
+            }
+            if (rc == 0) rc = dump_check(teptris_builder_close(b));
+        } else {
+            rc = put_scalar(b, ks, klen, v);
+        }
+        Py_DECREF(kb);
+    }
+    Py_LeaveRecursiveCall();
+    return rc;
+}
+
+static PyObject *ext_dumps(PyObject *self, PyObject *args) {
+    (void)self;
+    PyObject *obj;
+    if (!PyArg_ParseTuple(args, "O", &obj)) return NULL;
+    if (!PyDict_Check(obj)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "dumps() expects a dict at the top level");
+        return NULL;
+    }
+    teptris_builder *b = teptris_builder_new();
+    if (!b) return PyErr_NoMemory();
+    if (build_table(b, obj) < 0) {
+        teptris_builder_free(b);
+        return NULL;
+    }
+    teptris_document *doc = NULL;
+    teptris_status st = teptris_builder_finish(b, &doc);
+    if (st != TEPTRIS_OK) {
+        teptris_builder_free(b);
+        PyErr_SetString(PyExc_TypeError, teptris_status_string(st));
+        return NULL;
+    }
+    char *buf = NULL;
+    size_t len = 0;
+    st = teptris_document_emit(doc, &buf, &len);
+    teptris_document_free(doc);
+    teptris_builder_free(b); /* finish() transferred (and freed) the doc */
+    if (st != TEPTRIS_OK) return PyErr_NoMemory();
+    PyObject *out = PyUnicode_DecodeUTF8(buf, (Py_ssize_t)len, "strict");
+    free(buf);
+    return out;
+}
+
+static PyMethodDef methods[] = {
+    {"loads", ext_load, METH_VARARGS, "Parse TOML into Python objects."},
+    {"dumps", ext_dumps, METH_VARARGS,
+     "Serialize a dict tree to canonical TOML via the shared emitter."},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef mod = {PyModuleDef_HEAD_INIT, "teptris._native",
+    "Native teptris binding (no fallback).", -1, methods};
+
+PyMODINIT_FUNC PyInit__native(void) {
+    PyObject *m = PyModule_Create(&mod);
+    if (!m) return NULL;
+    PyObject *dtmod = PyImport_ImportModule("datetime");
+    if (dtmod == NULL) { Py_DECREF(m); return NULL; }
+    tep_dt_datetime = PyObject_GetAttrString(dtmod, "datetime");
+    tep_dt_date = PyObject_GetAttrString(dtmod, "date");
+    tep_dt_time = PyObject_GetAttrString(dtmod, "time");
+    tep_dt_timedelta = PyObject_GetAttrString(dtmod, "timedelta");
+    tep_dt_timezone = PyObject_GetAttrString(dtmod, "timezone");
+    Py_DECREF(dtmod);
+    if (!tep_dt_datetime || !tep_dt_date || !tep_dt_time ||
+        !tep_dt_timedelta || !tep_dt_timezone) {
+        Py_DECREF(m);
+        return NULL;
+    }
+    TomlDecodeError = PyErr_NewException("teptris._native.DecodeError", NULL, NULL);
+    Py_INCREF(TomlDecodeError);
+    PyModule_AddObject(m, "DecodeError", TomlDecodeError);
+    return m;
+}