Merge pull request #5 from SnoopJ/feature/pure-python-impl

Switch to pure Python implementation

Author: SnoopJ

.github/workflows/build_wheels.yml

@@ -14,16 +14,11 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.22.0
-        env:
-          CIBW_TEST_REQUIRES: pytest
-          CIBW_TEST_COMMAND: pytest -v {project}/tests
-        # default values:
-        # with:
-        #   package-dir: .
-        #   output-dir: wheelhouse
-        #   config-file: "{package}/pyproject.toml"
+        run: |
+          python3 -m pip install .[dev]
+          python3 -m pytest
+          python3 -m build .
 
       - uses: actions/upload-artifact@v4
         with:
-          path: ./wheelhouse/*.whl
+          path: ./dist/*.whl

MANIFEST.in

@@ -27,7 +27,6 @@ less memory (~30 KB), and it was kinda fun to write besides :)
 
 The script `makeunicode_age.py` consumes
 [`DerivedAge.txt`](https://www.unicode.org/reports/tr44/#DerivedAge.txt) and
-produces the header file that holds the backing data for this module and fills
-in the number of spans in the Cython template. To make a build for another
-version of the Unicode Character Database, you should be able to replace
-`DerivedAge.txt` and re-run this script.
+produces the `unicode_age_db.py` file that holds the backing data for this
+library. To make a build for another version of the Unicode Character Database,
+you should be able to replace `DerivedAge.txt` and re-run this script.

README.md

@@ -1,57 +1,49 @@
-from pathlib import Path
-import pprint
+from __future__ import annotations
 import re
-import string
+import struct
 import sys
+from pathlib import Path
 from textwrap import dedent
 
 
 HERE = Path(__file__).parent.resolve()
 DERIVEDAGES = HERE.joinpath("DerivedAge.txt")
 
-CYTHON_INFILE = HERE.joinpath("unicode_age.pyx.in")
-CYTHON_TEMPLATE = string.Template(CYTHON_INFILE.read_text())
 
+def _write_spans(spans: list, ucd_version: tuple, outfile: Path):
+    span_fmt = "iibb"
+    VersionSpan = struct.Struct(span_fmt)
 
-def _write_spans(spans: list, c_out: Path, cython_out: Path):
-    c_src = dedent("""
-    // 8 + 8 + 2 = 18 bytes per span
-    // 1283 'real' spans, 435 singleton spans as of Unicode 15.0
-    // ~31 KB of storage required (in practice the actual consumed memory is ~21 KB? not sure why that is...)
-    typedef struct {
-            int start;
-            int stop;
-            char major;
-            char minor;
-    } versionSpan_t;
+    Nbytes = len(spans) * VersionSpan.size
+    buf = bytearray(Nbytes)
 
+    for n, s in enumerate(spans):
+        VersionSpan.pack_into(buf, n*VersionSpan.size, *s)
 
-    static const versionSpan_t versionSpans[] = {
-    """)
-
-    c_src += "\t"
+    py_src = dedent(f"""
+    from __future__ import annotations
+    import struct
 
-    for (start, stop, major, minor) in spans:
-        line = f"{{0x{start:06x}, 0x{stop:06x}, {major}, {minor}}}"
-        c_src += f"{line},\n\t"
+    UCD_VERSION = {ucd_version}
 
-    c_src += "\n};"
+    VersionSpan = struct.Struct({span_fmt!r})
 
-    pyx_src = CYTHON_TEMPLATE.substitute({"numSpans": len(spans)})
+    def iter_spans():
+        yield from VersionSpan.iter_unpack(VERSION_SPANS)
 
+    VERSION_SPANS = {repr(buf)}
+    """)
 
-    c_out.write_text(c_src)
-    print(f"Wrote to {c_out}")
 
-    cython_out.write_text(pyx_src)
-    print(f"Wrote to {cython_out}")
+    outfile.write_text(py_src)
+    print(f"Wrote to {outfile}")
 
 
-def _derivedage_spans():
+def _derivedage_spans(fn):
     CODEPT = r"[0-9A-Fa-f]+"
     PATT = rf"^({CODEPT})(?:\.\.({CODEPT}))?\s*;\s*([\d.]+)\s*#.*"
 
-    with open(DERIVEDAGES, "r") as f:
+    with open(fn, "r") as f:
         for line in f:
             if line.strip() and line.startswith("#"):
                 continue
@@ -69,14 +61,31 @@ def _derivedage_spans():
                 yield start, stop, major, minor
 
 
+def parse_ucdversion(fn: Path) -> tuple[int, int, int]:
+    with open(fn, "r") as f:
+        patt = r"DerivedAge-(?P<version>\d+\.\d+\.\d+)\.txt"
+        m = re.search(patt, f.readline())
+        if not m:
+            raise ValueError("Cannot determine UCD version of {str(fn)!r}")
 
-def main():
-    spans = list(_derivedage_spans())
+    ver = tuple(int(val) for val in m.group("version").split('.'))
+    return ver
 
-    C_OUTFILE = HERE.joinpath("src", "unicode_age.h")
-    CYTHON_OUTFILE = HERE.joinpath("src", "unicode_age.pyx")
 
-    _write_spans(spans, c_out=C_OUTFILE, cython_out=CYTHON_OUTFILE)
+def main():
+    ucd_version = parse_ucdversion(DERIVEDAGES)
+    print(f"Scanning for version spans for UCD {ucd_version}: {str(DERIVEDAGES)}")
+    spans = list(_derivedage_spans(DERIVEDAGES))
+    print(f"Found {len(spans)} versioned spans")
+
+    UNICODE_AGE = HERE.joinpath("src", "unicode_age")
+    PYTHON_OUTFILE = UNICODE_AGE.joinpath("unicode_age_db.py")
+
+    _write_spans(
+        spans,
+        ucd_version=ucd_version,
+        outfile=PYTHON_OUTFILE,
+    )
 
 
 if __name__ == "__main__":

makeunicode_age.py

@@ -9,15 +9,12 @@ readme = "README.md"
 [project.optional-dependencies]
 dev = [
     "pytest",
-    "scriv[toml]",
     "twine",
-    "cibuildwheel",
-    "Cython",
     "build",
 ]
 
 [build-system]
-requires = ["setuptools", "wheel", "Cython"]
+requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
 [tool.tox]
@@ -29,11 +26,3 @@ envlist = py{38,39,310}, pypy{38,39}
 deps = pytest
 commands = pytest
 """
-
-[tool.cibuildwheel]
-test-requires = "pytest"
-test-command = "pytest -v {project}/tests"
-
-[tool.scriv]
-version = "literal: pyproject.toml: project.version"
-fragment_directory = "news"