jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test/test_serialization.py

@@ -1,108 +0,0 @@
-"""Functions to check that serialization round-tripped properly."""
-
-# This file is named test_serialization.py even though it doesn't
-# contain its own tests so that pytest will rewrite the asserts...
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-from typing import Any
-
-from mypyc.ir.class_ir import ClassIR
-from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature
-from mypyc.ir.module_ir import ModuleIR, deserialize_modules
-from mypyc.ir.ops import DeserMaps
-from mypyc.ir.rtypes import RType
-from mypyc.sametype import is_same_signature, is_same_type
-
-
-def get_dict(x: Any) -> dict[str, Any]:
-    if hasattr(x, "__mypyc_attrs__"):
-        return {k: getattr(x, k) for k in x.__mypyc_attrs__ if hasattr(x, k)}
-    else:
-        return dict(x.__dict__)
-
-
-def get_function_dict(x: FuncIR) -> dict[str, Any]:
-    """Get a dict of function attributes safe to compare across serialization"""
-    d = get_dict(x)
-    d.pop("blocks", None)
-    d.pop("env", None)
-    return d
-
-
-def assert_blobs_same(x: Any, y: Any, trail: tuple[Any, ...]) -> None:
-    """Compare two blobs of IR as best we can.
-
-    FuncDecls, FuncIRs, and ClassIRs are compared by fullname to avoid
-    infinite recursion.
-    (More detailed comparisons should be done manually.)
-
-    Types and signatures are compared using mypyc.sametype.
-
-    Containers are compared recursively.
-
-    Anything else is compared with ==.
-
-    The `trail` argument is used in error messages.
-    """
-
-    assert type(x) is type(y), (f"Type mismatch at {trail}", type(x), type(y))
-    if isinstance(x, (FuncDecl, FuncIR, ClassIR)):
-        assert x.fullname == y.fullname, f"Name mismatch at {trail}"
-    elif isinstance(x, dict):
-        assert len(x.keys()) == len(y.keys()), f"Keys mismatch at {trail}"
-        for (xk, xv), (yk, yv) in zip(x.items(), y.items()):
-            assert_blobs_same(xk, yk, trail + ("keys",))
-            assert_blobs_same(xv, yv, trail + (xk,))
-    elif isinstance(x, dict):
-        assert x.keys() == y.keys(), f"Keys mismatch at {trail}"
-        for k in x.keys():
-            assert_blobs_same(x[k], y[k], trail + (k,))
-    elif isinstance(x, Iterable) and not isinstance(x, (str, set)):
-        # Special case iterables to generate better assert error messages.
-        # We can't use this for sets since the ordering is unpredictable,
-        # and strings should be treated as atomic values.
-        for i, (xv, yv) in enumerate(zip(x, y)):
-            assert_blobs_same(xv, yv, trail + (i,))
-    elif isinstance(x, RType):
-        assert is_same_type(x, y), f"RType mismatch at {trail}"
-    elif isinstance(x, FuncSignature):
-        assert is_same_signature(x, y), f"Signature mismatch at {trail}"
-    else:
-        assert x == y, f"Value mismatch at {trail}"
-
-
-def assert_modules_same(ir1: ModuleIR, ir2: ModuleIR) -> None:
-    """Assert that two module IRs are the same (*).
-
-    * Or rather, as much as we care about preserving across
-    serialization.  We drop the actual IR bodies of functions but try
-    to preserve everything else.
-    """
-    assert ir1.fullname == ir2.fullname
-
-    assert ir1.imports == ir2.imports
-
-    for cls1, cls2 in zip(ir1.classes, ir2.classes):
-        assert_blobs_same(get_dict(cls1), get_dict(cls2), (ir1.fullname, cls1.fullname))
-
-    for fn1, fn2 in zip(ir1.functions, ir2.functions):
-        assert_blobs_same(
-            get_function_dict(fn1), get_function_dict(fn2), (ir1.fullname, fn1.fullname)
-        )
-        assert_blobs_same(get_dict(fn1.decl), get_dict(fn2.decl), (ir1.fullname, fn1.fullname))
-
-    assert_blobs_same(ir1.final_names, ir2.final_names, (ir1.fullname, "final_names"))
-
-
-def check_serialization_roundtrip(irs: dict[str, ModuleIR]) -> None:
-    """Check that we can serialize modules out and deserialize them to the same thing."""
-    serialized = {k: ir.serialize() for k, ir in irs.items()}
-
-    ctx = DeserMaps({}, {})
-    irs2 = deserialize_modules(serialized, ctx)
-    assert irs.keys() == irs2.keys()
-
-    for k in irs:
-        assert_modules_same(irs[k], irs2[k])

jaclang/vendor/mypyc/test/test_struct.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from mypyc.ir.rtypes import (
-    RStruct,
-    bool_rprimitive,
-    int32_rprimitive,
-    int64_rprimitive,
-    int_rprimitive,
-    object_rprimitive,
-)
-from mypyc.rt_subtype import is_runtime_subtype
-
-
-class TestStruct(unittest.TestCase):
-    def test_struct_offsets(self) -> None:
-        # test per-member alignment
-        r = RStruct("", [], [bool_rprimitive, int32_rprimitive, int64_rprimitive])
-        assert r.size == 16
-        assert r.offsets == [0, 4, 8]
-
-        # test final alignment
-        r1 = RStruct("", [], [bool_rprimitive, bool_rprimitive])
-        assert r1.size == 2
-        assert r1.offsets == [0, 1]
-        r2 = RStruct("", [], [int32_rprimitive, bool_rprimitive])
-        r3 = RStruct("", [], [int64_rprimitive, bool_rprimitive])
-        assert r2.offsets == [0, 4]
-        assert r3.offsets == [0, 8]
-        assert r2.size == 8
-        assert r3.size == 16
-
-        r4 = RStruct("", [], [bool_rprimitive, bool_rprimitive, bool_rprimitive, int32_rprimitive])
-        assert r4.size == 8
-        assert r4.offsets == [0, 1, 2, 4]
-
-        # test nested struct
-        r5 = RStruct("", [], [bool_rprimitive, r])
-        assert r5.offsets == [0, 8]
-        assert r5.size == 24
-        r6 = RStruct("", [], [int32_rprimitive, r5])
-        assert r6.offsets == [0, 8]
-        assert r6.size == 32
-        # test nested struct with alignment less than 8
-        r7 = RStruct("", [], [bool_rprimitive, r4])
-        assert r7.offsets == [0, 4]
-        assert r7.size == 12
-
-    def test_struct_str(self) -> None:
-        r = RStruct("Foo", ["a", "b"], [bool_rprimitive, object_rprimitive])
-        assert str(r) == "Foo{a:bool, b:object}"
-        assert (
-            repr(r) == "<RStruct Foo{a:<RPrimitive builtins.bool>, "
-            "b:<RPrimitive builtins.object>}>"
-        )
-        r1 = RStruct("Bar", ["c"], [int32_rprimitive])
-        assert str(r1) == "Bar{c:i32}"
-        assert repr(r1) == "<RStruct Bar{c:<RPrimitive i32>}>"
-        r2 = RStruct("Baz", [], [])
-        assert str(r2) == "Baz{}"
-        assert repr(r2) == "<RStruct Baz{}>"
-
-    def test_runtime_subtype(self) -> None:
-        # right type to check with
-        r = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
-
-        # using the exact same fields
-        r1 = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
-
-        # names different
-        r2 = RStruct("Bar", ["c", "b"], [bool_rprimitive, int_rprimitive])
-
-        # name different
-        r3 = RStruct("Baz", ["a", "b"], [bool_rprimitive, int_rprimitive])
-
-        # type different
-        r4 = RStruct("FooBar", ["a", "b"], [bool_rprimitive, int32_rprimitive])
-
-        # number of types different
-        r5 = RStruct(
-            "FooBarBaz", ["a", "b", "c"], [bool_rprimitive, int_rprimitive, bool_rprimitive]
-        )
-
-        assert is_runtime_subtype(r1, r) is True
-        assert is_runtime_subtype(r2, r) is False
-        assert is_runtime_subtype(r3, r) is False
-        assert is_runtime_subtype(r4, r) is False
-        assert is_runtime_subtype(r5, r) is False
-
-    def test_eq_and_hash(self) -> None:
-        r = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
-
-        # using the exact same fields
-        r1 = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
-        assert hash(r) == hash(r1)
-        assert r == r1
-
-        # different name
-        r2 = RStruct("Foq", ["a", "b"], [bool_rprimitive, int_rprimitive])
-        assert hash(r) != hash(r2)
-        assert r != r2
-
-        # different names
-        r3 = RStruct("Foo", ["a", "c"], [bool_rprimitive, int_rprimitive])
-        assert hash(r) != hash(r3)
-        assert r != r3
-
-        # different type
-        r4 = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive, bool_rprimitive])
-        assert hash(r) != hash(r4)
-        assert r != r4

jaclang/vendor/mypyc/test/test_tuplename.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from mypyc.ir.class_ir import ClassIR
-from mypyc.ir.rtypes import (
-    RInstance,
-    RTuple,
-    RUnion,
-    bool_rprimitive,
-    int_rprimitive,
-    list_rprimitive,
-    object_rprimitive,
-)
-
-
-class TestTupleNames(unittest.TestCase):
-    def setUp(self) -> None:
-        self.inst_a = RInstance(ClassIR("A", "__main__"))
-        self.inst_b = RInstance(ClassIR("B", "__main__"))
-
-    def test_names(self) -> None:
-        assert RTuple([int_rprimitive, int_rprimitive]).unique_id == "T2II"
-        assert RTuple([list_rprimitive, object_rprimitive, self.inst_a]).unique_id == "T3OOO"
-        assert RTuple([list_rprimitive, object_rprimitive, self.inst_b]).unique_id == "T3OOO"
-        assert RTuple([]).unique_id == "T0"
-        assert (
-            RTuple([RTuple([]), RTuple([int_rprimitive, int_rprimitive])]).unique_id == "T2T0T2II"
-        )
-        assert (
-            RTuple([bool_rprimitive, RUnion([bool_rprimitive, int_rprimitive])]).unique_id
-            == "T2CO"
-        )

jaclang/vendor/mypyc/test/test_typeops.py

@@ -1,97 +0,0 @@
-"""Test cases for various RType operations."""
-
-from __future__ import annotations
-
-import unittest
-
-from mypyc.ir.rtypes import (
-    RUnion,
-    bit_rprimitive,
-    bool_rprimitive,
-    int16_rprimitive,
-    int32_rprimitive,
-    int64_rprimitive,
-    int_rprimitive,
-    object_rprimitive,
-    short_int_rprimitive,
-    str_rprimitive,
-)
-from mypyc.rt_subtype import is_runtime_subtype
-from mypyc.subtype import is_subtype
-
-native_int_types = [int64_rprimitive, int32_rprimitive, int16_rprimitive]
-
-
-class TestSubtype(unittest.TestCase):
-    def test_bit(self) -> None:
-        assert is_subtype(bit_rprimitive, bool_rprimitive)
-        assert is_subtype(bit_rprimitive, int_rprimitive)
-        assert is_subtype(bit_rprimitive, short_int_rprimitive)
-        for rt in native_int_types:
-            assert is_subtype(bit_rprimitive, rt)
-
-    def test_bool(self) -> None:
-        assert not is_subtype(bool_rprimitive, bit_rprimitive)
-        assert is_subtype(bool_rprimitive, int_rprimitive)
-        assert is_subtype(bool_rprimitive, short_int_rprimitive)
-        for rt in native_int_types:
-            assert is_subtype(bool_rprimitive, rt)
-
-    def test_int64(self) -> None:
-        assert is_subtype(int64_rprimitive, int64_rprimitive)
-        assert is_subtype(int64_rprimitive, int_rprimitive)
-        assert not is_subtype(int64_rprimitive, short_int_rprimitive)
-        assert not is_subtype(int64_rprimitive, int32_rprimitive)
-        assert not is_subtype(int64_rprimitive, int16_rprimitive)
-
-    def test_int32(self) -> None:
-        assert is_subtype(int32_rprimitive, int32_rprimitive)
-        assert is_subtype(int32_rprimitive, int_rprimitive)
-        assert not is_subtype(int32_rprimitive, short_int_rprimitive)
-        assert not is_subtype(int32_rprimitive, int64_rprimitive)
-        assert not is_subtype(int32_rprimitive, int16_rprimitive)
-
-    def test_int16(self) -> None:
-        assert is_subtype(int16_rprimitive, int16_rprimitive)
-        assert is_subtype(int16_rprimitive, int_rprimitive)
-        assert not is_subtype(int16_rprimitive, short_int_rprimitive)
-        assert not is_subtype(int16_rprimitive, int64_rprimitive)
-        assert not is_subtype(int16_rprimitive, int32_rprimitive)
-
-
-class TestRuntimeSubtype(unittest.TestCase):
-    def test_bit(self) -> None:
-        assert is_runtime_subtype(bit_rprimitive, bool_rprimitive)
-        assert not is_runtime_subtype(bit_rprimitive, int_rprimitive)
-
-    def test_bool(self) -> None:
-        assert not is_runtime_subtype(bool_rprimitive, bit_rprimitive)
-        assert not is_runtime_subtype(bool_rprimitive, int_rprimitive)
-
-    def test_union(self) -> None:
-        bool_int_mix = RUnion([bool_rprimitive, int_rprimitive])
-        assert not is_runtime_subtype(bool_int_mix, short_int_rprimitive)
-        assert not is_runtime_subtype(bool_int_mix, int_rprimitive)
-        assert not is_runtime_subtype(short_int_rprimitive, bool_int_mix)
-        assert not is_runtime_subtype(int_rprimitive, bool_int_mix)
-
-
-class TestUnionSimplification(unittest.TestCase):
-    def test_simple_type_result(self) -> None:
-        assert RUnion.make_simplified_union([int_rprimitive]) == int_rprimitive
-
-    def test_remove_duplicate(self) -> None:
-        assert RUnion.make_simplified_union([int_rprimitive, int_rprimitive]) == int_rprimitive
-
-    def test_cannot_simplify(self) -> None:
-        assert RUnion.make_simplified_union(
-            [int_rprimitive, str_rprimitive, object_rprimitive]
-        ) == RUnion([int_rprimitive, str_rprimitive, object_rprimitive])
-
-    def test_nested(self) -> None:
-        assert RUnion.make_simplified_union(
-            [int_rprimitive, RUnion([str_rprimitive, int_rprimitive])]
-        ) == RUnion([int_rprimitive, str_rprimitive])
-        assert RUnion.make_simplified_union(
-            [int_rprimitive, RUnion([str_rprimitive, RUnion([int_rprimitive])])]
-        ) == RUnion([int_rprimitive, str_rprimitive])

jaclang/vendor/mypyc/test/testutil.py

@@ -1,283 +0,0 @@
-"""Helpers for writing tests"""
-
-from __future__ import annotations
-
-import contextlib
-import os
-import os.path
-import re
-import shutil
-from typing import Callable, Iterator
-
-from mypy import build
-from mypy.errors import CompileError
-from mypy.options import Options
-from mypy.test.config import test_temp_dir
-from mypy.test.data import DataDrivenTestCase, DataSuite
-from mypy.test.helpers import assert_string_arrays_equal
-from mypyc.analysis.ircheck import assert_func_ir_valid
-from mypyc.common import IS_32_BIT_PLATFORM, PLATFORM_SIZE
-from mypyc.errors import Errors
-from mypyc.ir.func_ir import FuncIR
-from mypyc.ir.module_ir import ModuleIR
-from mypyc.irbuild.main import build_ir
-from mypyc.irbuild.mapper import Mapper
-from mypyc.options import CompilerOptions
-from mypyc.test.config import test_data_prefix
-
-# The builtins stub used during icode generation test cases.
-ICODE_GEN_BUILTINS = os.path.join(test_data_prefix, "fixtures/ir.py")
-# The testutil support library
-TESTUTIL_PATH = os.path.join(test_data_prefix, "fixtures/testutil.py")
-
-
-class MypycDataSuite(DataSuite):
-    # Need to list no files, since this will be picked up as a suite of tests
-    files: list[str] = []
-    data_prefix = test_data_prefix
-
-
-def builtins_wrapper(
-    func: Callable[[DataDrivenTestCase], None], path: str
-) -> Callable[[DataDrivenTestCase], None]:
-    """Decorate a function that implements a data-driven test case to copy an
-    alternative builtins module implementation in place before performing the
-    test case. Clean up after executing the test case.
-    """
-    return lambda testcase: perform_test(func, path, testcase)
-
-
-@contextlib.contextmanager
-def use_custom_builtins(builtins_path: str, testcase: DataDrivenTestCase) -> Iterator[None]:
-    for path, _ in testcase.files:
-        if os.path.basename(path) == "builtins.pyi":
-            default_builtins = False
-            break
-    else:
-        # Use default builtins.
-        builtins = os.path.abspath(os.path.join(test_temp_dir, "builtins.pyi"))
-        shutil.copyfile(builtins_path, builtins)
-        default_builtins = True
-
-    # Actually perform the test case.
-    try:
-        yield None
-    finally:
-        if default_builtins:
-            # Clean up.
-            os.remove(builtins)
-
-
-def perform_test(
-    func: Callable[[DataDrivenTestCase], None], builtins_path: str, testcase: DataDrivenTestCase
-) -> None:
-    for path, _ in testcase.files:
-        if os.path.basename(path) == "builtins.py":
-            default_builtins = False
-            break
-    else:
-        # Use default builtins.
-        builtins = os.path.join(test_temp_dir, "builtins.py")
-        shutil.copyfile(builtins_path, builtins)
-        default_builtins = True
-
-    # Actually perform the test case.
-    func(testcase)
-
-    if default_builtins:
-        # Clean up.
-        os.remove(builtins)
-
-
-def build_ir_for_single_file(
-    input_lines: list[str], compiler_options: CompilerOptions | None = None
-) -> list[FuncIR]:
-    return build_ir_for_single_file2(input_lines, compiler_options).functions
-
-
-def build_ir_for_single_file2(
-    input_lines: list[str], compiler_options: CompilerOptions | None = None
-) -> ModuleIR:
-    program_text = "\n".join(input_lines)
-
-    # By default generate IR compatible with the earliest supported Python C API.
-    # If a test needs more recent API features, this should be overridden.
-    compiler_options = compiler_options or CompilerOptions(capi_version=(3, 7))
-    options = Options()
-    options.show_traceback = True
-    options.hide_error_codes = True
-    options.use_builtins_fixtures = True
-    options.strict_optional = True
-    options.python_version = compiler_options.python_version or (3, 6)
-    options.export_types = True
-    options.preserve_asts = True
-    options.allow_empty_bodies = True
-    options.per_module_options["__main__"] = {"mypyc": True}
-
-    source = build.BuildSource("main", "__main__", program_text)
-    # Construct input as a single single.
-    # Parse and type check the input program.
-    result = build.build(sources=[source], options=options, alt_lib_path=test_temp_dir)
-    if result.errors:
-        raise CompileError(result.errors)
-
-    errors = Errors(options)
-    modules = build_ir(
-        [result.files["__main__"]],
-        result.graph,
-        result.types,
-        Mapper({"__main__": None}),
-        compiler_options,
-        errors,
-    )
-    if errors.num_errors:
-        raise CompileError(errors.new_messages())
-
-    module = list(modules.values())[0]
-    for fn in module.functions:
-        assert_func_ir_valid(fn)
-    return module
-
-
-def update_testcase_output(testcase: DataDrivenTestCase, output: list[str]) -> None:
-    # TODO: backport this to mypy
-    assert testcase.old_cwd is not None, "test was not properly set up"
-    testcase_path = os.path.join(testcase.old_cwd, testcase.file)
-    with open(testcase_path) as f:
-        data_lines = f.read().splitlines()
-
-    # We can't rely on the test line numbers to *find* the test, since
-    # we might fix multiple tests in a run. So find it by the case
-    # header. Give up if there are multiple tests with the same name.
-    test_slug = f"[case {testcase.name}]"
-    if data_lines.count(test_slug) != 1:
-        return
-    start_idx = data_lines.index(test_slug)
-    stop_idx = start_idx + 11
-    while stop_idx < len(data_lines) and not data_lines[stop_idx].startswith("[case "):
-        stop_idx += 1
-
-    test = data_lines[start_idx:stop_idx]
-    out_start = test.index("[out]")
-    test[out_start + 1 :] = output
-    data_lines[start_idx:stop_idx] = test + [""]
-    data = "\n".join(data_lines)
-
-    with open(testcase_path, "w") as f:
-        print(data, file=f)
-
-
-def assert_test_output(
-    testcase: DataDrivenTestCase,
-    actual: list[str],
-    message: str,
-    expected: list[str] | None = None,
-    formatted: list[str] | None = None,
-) -> None:
-    __tracebackhide__ = True
-
-    expected_output = expected if expected is not None else testcase.output
-    if expected_output != actual and testcase.config.getoption("--update-data", False):
-        update_testcase_output(testcase, actual)
-
-    assert_string_arrays_equal(
-        expected_output, actual, f"{message} ({testcase.file}, line {testcase.line})"
-    )
-
-
-def get_func_names(expected: list[str]) -> list[str]:
-    res = []
-    for s in expected:
-        m = re.match(r"def ([_a-zA-Z0-9.*$]+)\(", s)
-        if m:
-            res.append(m.group(1))
-    return res
-
-
-def remove_comment_lines(a: list[str]) -> list[str]:
-    """Return a copy of array with comments removed.
-
-    Lines starting with '--' (but not with '---') are removed.
-    """
-    r = []
-    for s in a:
-        if s.strip().startswith("--") and not s.strip().startswith("---"):
-            pass
-        else:
-            r.append(s)
-    return r
-
-
-def print_with_line_numbers(s: str) -> None:
-    lines = s.splitlines()
-    for i, line in enumerate(lines):
-        print("%-4d %s" % (i + 1, line))
-
-
-def heading(text: str) -> None:
-    print("=" * 20 + " " + text + " " + "=" * 20)
-
-
-def show_c(cfiles: list[list[tuple[str, str]]]) -> None:
-    heading("Generated C")
-    for group in cfiles:
-        for cfile, ctext in group:
-            print(f"== {cfile} ==")
-            print_with_line_numbers(ctext)
-    heading("End C")
-
-
-def fudge_dir_mtimes(dir: str, delta: int) -> None:
-    for dirpath, _, filenames in os.walk(dir):
-        for name in filenames:
-            path = os.path.join(dirpath, name)
-            new_mtime = os.stat(path).st_mtime + delta
-            os.utime(path, times=(new_mtime, new_mtime))
-
-
-def replace_word_size(text: list[str]) -> list[str]:
-    """Replace WORDSIZE with platform specific word sizes"""
-    result = []
-    for line in text:
-        index = line.find("WORD_SIZE")
-        if index != -1:
-            # get 'WORDSIZE*n' token
-            word_size_token = line[index:].split()[0]
-            n = int(word_size_token[10:])
-            replace_str = str(PLATFORM_SIZE * n)
-            result.append(line.replace(word_size_token, replace_str))
-        else:
-            result.append(line)
-    return result
-
-
-def infer_ir_build_options_from_test_name(name: str) -> CompilerOptions | None:
-    """Look for magic substrings in test case name to set compiler options.
-
-    Return None if the test case should be skipped (always pass).
-
-    Supported naming conventions:
-
-      *_64bit*:
-          Run test case only on 64-bit platforms
-      *_32bit*:
-          Run test caseonly on 32-bit platforms
-      *_python3_8* (or for any Python version):
-          Use Python 3.8+ C API features (default: lowest supported version)
-      *StripAssert*:
-          Don't generate code for assert statements
-    """
-    # If this is specific to some bit width, always pass if platform doesn't match.
-    if "_64bit" in name and IS_32_BIT_PLATFORM:
-        return None
-    if "_32bit" in name and not IS_32_BIT_PLATFORM:
-        return None
-    options = CompilerOptions(strip_asserts="StripAssert" in name, capi_version=(3, 7))
-    # A suffix like _python3.8 is used to set the target C API version.
-    m = re.search(r"_python([3-9]+)_([0-9]+)(_|\b)", name)
-    if m:
-        options.capi_version = (int(m.group(1)), int(m.group(2)))
-        options.python_version = options.capi_version
-    elif "_py" in name or "_Python" in name:
-        assert False, f"Invalid _py* suffix (should be _pythonX_Y): {name}"
-    return options