some new features

.venv/lib/python3.12/site-packages/Cython/Tests/TestCodeWriter.py

@@ -0,0 +1,128 @@
+from Cython.TestUtils import CythonTest
+
+class TestCodeWriter(CythonTest):
+    # CythonTest uses the CodeWriter heavily, so do some checking by
+    # roundtripping Cython code through the test framework.
+
+    # Note that this test is dependent upon the normal Cython parser
+    # to generate the input trees to the CodeWriter. This save *a lot*
+    # of time; better to spend that time writing other tests than perfecting
+    # this one...
+
+    # Whitespace is very significant in this process:
+    #  - always newline on new block (!)
+    #  - indent 4 spaces
+    #  - 1 space around every operator
+
+    def t(self, codestr):
+        self.assertCode(codestr, self.fragment(codestr).root)
+
+    def test_print(self):
+        self.t(u"""
+                    print(x + y ** 2)
+                    print(x, y, z)
+                    print(x + y, x + y * z, x * (y + z))
+               """)
+
+    def test_if(self):
+        self.t(u"if x:\n    pass")
+
+    def test_ifelifelse(self):
+        self.t(u"""
+                    if x:
+                        pass
+                    elif y:
+                        pass
+                    elif z + 34 ** 34 - 2:
+                        pass
+                    else:
+                        pass
+                """)
+
+    def test_def(self):
+        self.t(u"""
+                    def f(x, y, z):
+                        pass
+                    def f(x = 34, y = 54, z):
+                        pass
+               """)
+
+    def test_cdef(self):
+        self.t(u"""
+                    cdef f(x, y, z):
+                        pass
+                    cdef public void (x = 34, y = 54, z):
+                        pass
+                    cdef f(int *x, void *y, Value *z):
+                        pass
+                    cdef f(int **x, void **y, Value **z):
+                        pass
+                    cdef inline f(int &x, Value &z):
+                        pass
+               """)
+
+    def test_longness_and_signedness(self):
+        self.t(u"def f(unsigned long long long long long int y):\n    pass")
+
+    def test_signed_short(self):
+        self.t(u"def f(signed short int y):\n    pass")
+
+    def test_typed_args(self):
+        self.t(u"def f(int x, unsigned long int y):\n    pass")
+
+    def test_cdef_var(self):
+        self.t(u"""
+                    cdef int hello
+                    cdef int hello = 4, x = 3, y, z
+                """)
+
+    def test_for_loop(self):
+        self.t(u"""
+                    for x, y, z in f(g(h(34) * 2) + 23):
+                        print(x, y, z)
+                    else:
+                        print(43)
+                """)
+        self.t(u"""
+                    for abc in (1, 2, 3):
+                        print(x, y, z)
+                    else:
+                        print(43)
+                """)
+
+    def test_while_loop(self):
+        self.t(u"""
+                    while True:
+                        while True:
+                            while True:
+                                continue
+                """)
+
+    def test_inplace_assignment(self):
+        self.t(u"x += 43")
+
+    def test_cascaded_assignment(self):
+        self.t(u"x = y = z = abc = 43")
+
+    def test_attribute(self):
+        self.t(u"a.x")
+
+    def test_return_none(self):
+        self.t(u"""
+                    def f(x, y, z):
+                        return
+                    cdef f(x, y, z):
+                        return
+                    def f(x, y, z):
+                        return None
+                    cdef f(x, y, z):
+                        return None
+                    def f(x, y, z):
+                        return 1234
+                    cdef f(x, y, z):
+                        return 1234
+               """)
+
+if __name__ == "__main__":
+    import unittest
+    unittest.main()

.venv/lib/python3.12/site-packages/Cython/Tests/TestCythonUtils.py

@@ -0,0 +1,205 @@
+import sys
+import unittest
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO  # doesn't accept 'str' in Py2
+
+from Cython.Utils import (
+    _CACHE_NAME_PATTERN, _build_cache_name, _find_cache_attributes,
+    build_hex_version, cached_method, clear_method_caches, try_finally_contextmanager,
+    print_version, normalise_float_repr,
+)
+
+METHOD_NAME = "cached_next"
+CACHE_NAME = _build_cache_name(METHOD_NAME)
+NAMES = CACHE_NAME, METHOD_NAME
+
+class Cached(object):
+    @cached_method
+    def cached_next(self, x):
+        return next(x)
+
+
+class TestCythonUtils(unittest.TestCase):
+    def test_build_hex_version(self):
+        self.assertEqual('0x001D00A1', build_hex_version('0.29a1'))
+        self.assertEqual('0x001D03C4', build_hex_version('0.29.3rc4'))
+        self.assertEqual('0x001D00F0', build_hex_version('0.29'))
+        self.assertEqual('0x040000F0', build_hex_version('4.0'))
+
+    ############################## Cached Methods ##############################
+
+    def test_cache_method_name(self):
+        method_name = "foo"
+        cache_name = _build_cache_name(method_name)
+        match = _CACHE_NAME_PATTERN.match(cache_name)
+
+        self.assertIsNot(match, None)
+        self.assertEqual(match.group(1), method_name)
+
+    def test_requirements_for_Cached(self):
+        obj = Cached()
+
+        self.assertFalse(hasattr(obj, CACHE_NAME))
+        self.assertTrue(hasattr(obj, METHOD_NAME))
+        self.set_of_names_equal(obj, set())
+
+    def set_of_names_equal(self, obj, value):
+        self.assertEqual(set(_find_cache_attributes(obj)), value)
+
+    def test_find_cache_attributes(self):
+        obj = Cached()
+        method_name = "bar"
+        cache_name = _build_cache_name(method_name)
+
+        setattr(obj, CACHE_NAME, {})
+        setattr(obj, cache_name, {})
+
+        self.assertFalse(hasattr(obj, method_name))
+        self.set_of_names_equal(obj, {NAMES, (cache_name, method_name)})
+
+    def test_cached_method(self):
+        obj = Cached()
+        value = iter(range(3))  # iter for Py2
+        cache = {(value,): 0}
+
+        # cache args
+        self.assertEqual(obj.cached_next(value), 0)
+        self.set_of_names_equal(obj, {NAMES})
+        self.assertEqual(getattr(obj, CACHE_NAME), cache)
+
+        # use cache
+        self.assertEqual(obj.cached_next(value), 0)
+        self.set_of_names_equal(obj, {NAMES})
+        self.assertEqual(getattr(obj, CACHE_NAME), cache)
+
+    def test_clear_method_caches(self):
+        obj = Cached()
+        value = iter(range(3))  # iter for Py2
+        cache = {(value,): 1}
+
+        obj.cached_next(value)  # cache args
+
+        clear_method_caches(obj)
+        self.set_of_names_equal(obj, set())
+
+        self.assertEqual(obj.cached_next(value), 1)
+        self.set_of_names_equal(obj, {NAMES})
+        self.assertEqual(getattr(obj, CACHE_NAME), cache)
+
+    def test_clear_method_caches_with_missing_method(self):
+        obj = Cached()
+        method_name = "bar"
+        cache_name = _build_cache_name(method_name)
+        names = cache_name, method_name
+
+        setattr(obj, cache_name, object())
+
+        self.assertFalse(hasattr(obj, method_name))
+        self.set_of_names_equal(obj, {names})
+
+        clear_method_caches(obj)
+        self.set_of_names_equal(obj, {names})
+
+    def test_try_finally_contextmanager(self):
+        states = []
+        @try_finally_contextmanager
+        def gen(*args, **kwargs):
+            states.append("enter")
+            yield (args, kwargs)
+            states.append("exit")
+
+        with gen(1, 2, 3, x=4) as call_args:
+            assert states == ["enter"]
+            self.assertEqual(call_args, ((1, 2, 3), {'x': 4}))
+        assert states == ["enter", "exit"]
+
+        class MyException(RuntimeError):
+            pass
+
+        del states[:]
+        with self.assertRaises(MyException):
+            with gen(1, 2, y=4) as call_args:
+                assert states == ["enter"]
+                self.assertEqual(call_args, ((1, 2), {'y': 4}))
+                raise MyException("FAIL INSIDE")
+            assert states == ["enter", "exit"]
+
+        del states[:]
+        with self.assertRaises(StopIteration):
+            with gen(1, 2, y=4) as call_args:
+                assert states == ["enter"]
+                self.assertEqual(call_args, ((1, 2), {'y': 4}))
+                raise StopIteration("STOP")
+            assert states == ["enter", "exit"]
+
+    def test_print_version(self):
+        orig_stderr = sys.stderr
+        orig_stdout = sys.stdout
+        stderr = sys.stderr = StringIO()
+        stdout = sys.stdout = StringIO()
+        try:
+            print_version()
+        finally:
+            sys.stdout = orig_stdout
+            sys.stderr = orig_stderr
+
+        stdout = stdout.getvalue()
+        stderr = stderr.getvalue()
+
+        from .. import __version__ as version
+        self.assertIn(version, stdout)
+        if stderr:  # Depends on os.fstat(1/2).
+            self.assertIn(version, stderr)
+
+    def test_print_version_stdouterr(self):
+        orig_stderr = sys.stderr
+        orig_stdout = sys.stdout
+        stdout = sys.stdout = sys.stderr = StringIO()  # same!
+        try:
+            print_version()
+        finally:
+            sys.stdout = orig_stdout
+            sys.stderr = orig_stderr
+
+        stdout = stdout.getvalue()
+
+        from .. import __version__ as version
+        self.assertIn(version, stdout)
+        self.assertEqual(stdout.count(version), 1)
+
+    def test_normalise_float_repr(self):
+        examples = [
+            ('.0', '.0'),
+            ('.000000', '.0'),
+            ('.1', '.1'),
+            ('1.', '1.'),
+            ('1.0', '1.'),
+            ('1.000000000000000000000', '1.'),
+            ('00000000000000000000001.000000000000000000000', '1.'),
+            ('12345.0025', '12345.0025'),
+            ('1E5', '100000.'),
+            ('.1E-5', '.000001'),
+            ('1.1E-5', '.000011'),
+            ('12.3E-5', '.000123'),
+            ('.1E10', '1000000000.'),
+            ('1.1E10', '11000000000.'),
+            ('123.4E10', '1234000000000.'),
+            ('123.456E0', '123.456'),
+            ('123.456E-1', '12.3456'),
+            ('123.456E-2', '1.23456'),
+            ('123.456E1', '1234.56'),
+            ('123.456E2', '12345.6'),
+            ('2.1E80', '210000000000000000000000000000000000000000000000000000000000000000000000000000000.'),
+        ]
+
+        for float_str, norm_str in examples:
+            self.assertEqual(float(float_str), float(norm_str))  # safety check for test data
+
+            result = normalise_float_repr(float_str)
+            self.assertEqual(float(float_str), float(result))
+            self.assertEqual(
+                result, norm_str,
+                "normalise_float_repr(%r) == %r != %r  (%.330f)" % (float_str, result, norm_str, float(float_str))
+            )

.venv/lib/python3.12/site-packages/Cython/Tests/TestJediTyper.py

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+# tag: jedi
+
+from __future__ import absolute_import
+
+import sys
+import os.path
+
+from textwrap import dedent
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+
+from Cython.Compiler.ParseTreeTransforms import NormalizeTree, InterpretCompilerDirectives
+from Cython.Compiler import Main, Symtab, Visitor, Options
+from Cython.TestUtils import TransformTest
+
+TOOLS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'Tools'))
+
+
+@contextmanager
+def _tempfile(code):
+    code = dedent(code)
+    if not isinstance(code, bytes):
+        code = code.encode('utf8')
+
+    with NamedTemporaryFile(suffix='.py') as f:
+        f.write(code)
+        f.seek(0)
+        yield f
+
+
+def _test_typing(code, inject=False):
+    sys.path.insert(0, TOOLS_DIR)
+    try:
+        import jedityper
+    finally:
+        sys.path.remove(TOOLS_DIR)
+    lines = []
+    with _tempfile(code) as f:
+        types = jedityper.analyse(f.name)
+        if inject:
+            lines = jedityper.inject_types(f.name, types)
+    return types, lines
+
+
+class DeclarationsFinder(Visitor.VisitorTransform):
+    directives = None
+
+    visit_Node = Visitor.VisitorTransform.recurse_to_children
+
+    def visit_CompilerDirectivesNode(self, node):
+        if not self.directives:
+            self.directives = []
+        self.directives.append(node)
+        self.visitchildren(node)
+        return node
+
+
+class TestJediTyper(TransformTest):
+    def _test(self, code):
+        return _test_typing(code)[0]
+
+    def test_typing_global_int_loop(self):
+        code = '''\
+        for i in range(10):
+            a = i + 1
+        '''
+        types = self._test(code)
+        self.assertIn((None, (1, 0)), types)
+        variables = types.pop((None, (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['int']), 'i': set(['int'])}, variables)
+
+    def test_typing_function_int_loop(self):
+        code = '''\
+        def func(x):
+            for i in range(x):
+                a = i + 1
+            return a
+        '''
+        types = self._test(code)
+        self.assertIn(('func', (1, 0)), types)
+        variables = types.pop(('func', (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['int']), 'i': set(['int'])}, variables)
+
+    def test_conflicting_types_in_function(self):
+        code = '''\
+        def func(a, b):
+            print(a)
+            a = 1
+            b += a
+            a = 'abc'
+            return a, str(b)
+
+        print(func(1.5, 2))
+        '''
+        types = self._test(code)
+        self.assertIn(('func', (1, 0)), types)
+        variables = types.pop(('func', (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['float', 'int', 'str']), 'b': set(['int'])}, variables)
+
+    def _test_typing_function_char_loop(self):
+        code = '''\
+        def func(x):
+            l = []
+            for c in x:
+                l.append(c)
+            return l
+
+        print(func('abcdefg'))
+        '''
+        types = self._test(code)
+        self.assertIn(('func', (1, 0)), types)
+        variables = types.pop(('func', (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['int']), 'i': set(['int'])}, variables)
+
+    def test_typing_global_list(self):
+        code = '''\
+        a = [x for x in range(10)]
+        b = list(range(10))
+        c = a + b
+        d = [0]*10
+        '''
+        types = self._test(code)
+        self.assertIn((None, (1, 0)), types)
+        variables = types.pop((None, (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['list']), 'b': set(['list']), 'c': set(['list']), 'd': set(['list'])}, variables)
+
+    def test_typing_function_list(self):
+        code = '''\
+        def func(x):
+            a = [[], []]
+            b = [0]* 10 + a
+            c = a[0]
+
+        print(func([0]*100))
+        '''
+        types = self._test(code)
+        self.assertIn(('func', (1, 0)), types)
+        variables = types.pop(('func', (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['list']), 'b': set(['list']), 'c': set(['list']), 'x': set(['list'])}, variables)
+
+    def test_typing_global_dict(self):
+        code = '''\
+        a = dict()
+        b = {i: i**2 for i in range(10)}
+        c = a
+        '''
+        types = self._test(code)
+        self.assertIn((None, (1, 0)), types)
+        variables = types.pop((None, (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['dict']), 'b': set(['dict']), 'c': set(['dict'])}, variables)
+
+    def test_typing_function_dict(self):
+        code = '''\
+        def func(x):
+            a = dict()
+            b = {i: i**2 for i in range(10)}
+            c = x
+
+        print(func({1:2, 'x':7}))
+        '''
+        types = self._test(code)
+        self.assertIn(('func', (1, 0)), types)
+        variables = types.pop(('func', (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['dict']), 'b': set(['dict']), 'c': set(['dict']), 'x': set(['dict'])}, variables)
+
+
+    def test_typing_global_set(self):
+        code = '''\
+        a = set()
+        # b = {i for i in range(10)} # jedi does not support set comprehension yet
+        c = a
+        d = {1,2,3}
+        e = a | b
+        '''
+        types = self._test(code)
+        self.assertIn((None, (1, 0)), types)
+        variables = types.pop((None, (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['set']), 'c': set(['set']), 'd': set(['set']), 'e': set(['set'])}, variables)
+
+    def test_typing_function_set(self):
+        code = '''\
+        def func(x):
+            a = set()
+            # b = {i for i in range(10)} # jedi does not support set comprehension yet
+            c = a
+            d = a | b
+
+        print(func({1,2,3}))
+        '''
+        types = self._test(code)
+        self.assertIn(('func', (1, 0)), types)
+        variables = types.pop(('func', (1, 0)))
+        self.assertFalse(types)
+        self.assertEqual({'a': set(['set']), 'c': set(['set']), 'd': set(['set']), 'x': set(['set'])}, variables)
+
+
+class TestTypeInjection(TestJediTyper):
+    """
+    Subtype of TestJediTyper that additionally tests type injection and compilation.
+    """
+    def setUp(self):
+        super(TestTypeInjection, self).setUp()
+        compilation_options = Options.CompilationOptions(Options.default_options)
+        ctx = Main.Context.from_options(compilation_options)
+        transform = InterpretCompilerDirectives(ctx, ctx.compiler_directives)
+        transform.module_scope = Symtab.ModuleScope('__main__', None, ctx)
+        self.declarations_finder = DeclarationsFinder()
+        self.pipeline = [NormalizeTree(None), transform, self.declarations_finder]
+
+    def _test(self, code):
+        types, lines = _test_typing(code, inject=True)
+        tree = self.run_pipeline(self.pipeline, ''.join(lines))
+        directives = self.declarations_finder.directives
+        # TODO: validate directives
+        return types

.venv/lib/python3.12/site-packages/Cython/Tests/TestShadow.py

@@ -0,0 +1,79 @@
+import unittest
+
+from Cython import Shadow
+from Cython.Compiler import Options, CythonScope, PyrexTypes, Errors
+
+class TestShadow(unittest.TestCase):
+    def test_all_types_in_shadow(self):
+        cython_scope = CythonScope.create_cython_scope(None)
+        # Not doing load_cythonscope at this stage because it requires a proper context and
+        # Errors.py to be set up
+
+        missing_types = []
+        for key in cython_scope.entries.keys():
+            if key.startswith('__') and key.endswith('__'):
+                continue
+            if key in ('PyTypeObject', 'PyObject_TypeCheck'):
+                # These are declared in Shadow.py for reasons that look to
+                # be an implementation detail, but it isn't our intention for
+                # users to access them from Pure Python mode.
+                continue
+            if not hasattr(Shadow, key):
+                missing_types.append(key)
+        self.assertEqual(missing_types, [])
+
+    def test_int_types_in_shadow(self):
+        missing_types = []
+        for int_name in Shadow.int_types:
+            for sign in ['', 'u', 's']:
+                name = sign + int_name
+
+                if sign and (
+                        int_name in ['Py_UNICODE', 'Py_UCS4', 'Py_ssize_t',
+                                     'ssize_t', 'ptrdiff_t', 'Py_hash_t'] or
+                        name == "usize_t"):
+                    # size_t is special-cased here a little since ssize_t legitimate
+                    # but usize_t isn't
+                    self.assertNotIn(name, dir(Shadow))
+                    self.assertNotIn('p_' + name, dir(Shadow))
+                    continue
+
+                if not hasattr(Shadow, name):
+                    missing_types.append(name)
+
+                for ptr in range(1, 4):
+                    ptr_name = 'p' * ptr + '_' + name
+                    if not hasattr(Shadow, ptr_name):
+                        missing_types.append(ptr_name)
+        self.assertEqual(missing_types, [])
+
+    def test_most_types(self):
+        # TODO it's unfortunately hard to get a definite list of types to confirm that they're
+        # present (because they're obtained by on-the-fly string parsing in `cython_scope.lookup_type`)
+
+        cython_scope = CythonScope.create_cython_scope(None)
+        # Set up just enough of "Context" and "Errors" that CythonScope.lookup_type can fail
+        class Context:
+            cpp = False
+            language_level = 3
+            future_directives = []
+        cython_scope.context = Context
+        Errors.init_thread()
+
+        missing_types = []
+        missing_lookups = []
+        for (signed, longness, name), type_ in PyrexTypes.modifiers_and_name_to_type.items():
+            if name == 'object':
+                continue  # This probably shouldn't be in Shadow
+            if not hasattr(Shadow, name):
+                missing_types.append(name)
+            if not cython_scope.lookup_type(name):
+                missing_lookups.append(name)
+            for ptr in range(1, 4):
+                ptr_name = 'p' * ptr + '_' + name
+                if not hasattr(Shadow, ptr_name):
+                    missing_types.append(ptr_name)
+                if not cython_scope.lookup_type(ptr_name):
+                    missing_lookups.append(ptr_name)
+        self.assertEqual(missing_types, [])
+        self.assertEqual(missing_lookups, [])

.venv/lib/python3.12/site-packages/Cython/Tests/TestStringIOTree.py

@@ -0,0 +1,67 @@
+import unittest
+
+from Cython import StringIOTree as stringtree
+
+code = """
+cdef int spam                   # line 1
+
+cdef ham():
+    a = 1
+    b = 2
+    c = 3
+    d = 4
+
+def eggs():
+    pass
+
+cpdef bacon():
+    print spam
+    print 'scotch'
+    print 'tea?'
+    print 'or coffee?'          # line 16
+"""
+
+linemap = dict(enumerate(code.splitlines()))
+
+class TestStringIOTree(unittest.TestCase):
+
+    def setUp(self):
+        self.tree = stringtree.StringIOTree()
+
+    def test_markers(self):
+        assert not self.tree.allmarkers()
+
+    def test_insertion(self):
+        self.write_lines((1, 2, 3))
+        line_4_to_6_insertion_point = self.tree.insertion_point()
+        self.write_lines((7, 8))
+        line_9_to_13_insertion_point = self.tree.insertion_point()
+        self.write_lines((14, 15, 16))
+
+        line_4_insertion_point = line_4_to_6_insertion_point.insertion_point()
+        self.write_lines((5, 6), tree=line_4_to_6_insertion_point)
+
+        line_9_to_12_insertion_point = (
+            line_9_to_13_insertion_point.insertion_point())
+        self.write_line(13, tree=line_9_to_13_insertion_point)
+
+        self.write_line(4, tree=line_4_insertion_point)
+        self.write_line(9, tree=line_9_to_12_insertion_point)
+        line_10_insertion_point = line_9_to_12_insertion_point.insertion_point()
+        self.write_line(11, tree=line_9_to_12_insertion_point)
+        self.write_line(10, tree=line_10_insertion_point)
+        self.write_line(12, tree=line_9_to_12_insertion_point)
+
+        self.assertEqual(self.tree.allmarkers(), list(range(1, 17)))
+        self.assertEqual(code.strip(), self.tree.getvalue().strip())
+
+
+    def write_lines(self, linenos, tree=None):
+        for lineno in linenos:
+            self.write_line(lineno, tree=tree)
+
+    def write_line(self, lineno, tree=None):
+        if tree is None:
+            tree = self.tree
+        tree.markers.append(lineno)
+        tree.write(linemap[lineno] + '\n')

.venv/lib/python3.12/site-packages/Cython/Tests/TestTestUtils.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+import os.path
+import unittest
+import tempfile
+import textwrap
+import shutil
+
+from ..TestUtils import write_file, write_newer_file, _parse_pattern
+
+
+class TestTestUtils(unittest.TestCase):
+    def setUp(self):
+        super(TestTestUtils, self).setUp()
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        if self.temp_dir and os.path.isdir(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+        super(TestTestUtils, self).tearDown()
+
+    def _test_path(self, filename):
+        return os.path.join(self.temp_dir, filename)
+
+    def _test_write_file(self, content, expected, **kwargs):
+        file_path = self._test_path("abcfile")
+        write_file(file_path, content, **kwargs)
+        assert os.path.isfile(file_path)
+
+        with open(file_path, 'rb') as f:
+            found = f.read()
+        assert found == expected, (repr(expected), repr(found))
+
+    def test_write_file_text(self):
+        text = u"abcüöä"
+        self._test_write_file(text, text.encode('utf8'))
+
+    def test_write_file_dedent(self):
+        text = u"""
+        A horse is a horse,
+        of course, of course,
+        And no one can talk to a horse
+        of course
+        """
+        self._test_write_file(text, textwrap.dedent(text).encode('utf8'), dedent=True)
+
+    def test_write_file_bytes(self):
+        self._test_write_file(b"ab\0c", b"ab\0c")
+
+    def test_write_newer_file(self):
+        file_path_1 = self._test_path("abcfile1.txt")
+        file_path_2 = self._test_path("abcfile2.txt")
+        write_file(file_path_1, "abc")
+        assert os.path.isfile(file_path_1)
+        write_newer_file(file_path_2, file_path_1, "xyz")
+        assert os.path.isfile(file_path_2)
+        assert os.path.getmtime(file_path_2) > os.path.getmtime(file_path_1)
+
+    def test_write_newer_file_same(self):
+        file_path = self._test_path("abcfile.txt")
+        write_file(file_path, "abc")
+        mtime = os.path.getmtime(file_path)
+        write_newer_file(file_path, file_path, "xyz")
+        assert os.path.getmtime(file_path) > mtime
+
+    def test_write_newer_file_fresh(self):
+        file_path = self._test_path("abcfile.txt")
+        assert not os.path.exists(file_path)
+        write_newer_file(file_path, file_path, "xyz")
+        assert os.path.isfile(file_path)
+
+    def test_parse_pattern(self):
+        self.assertEqual(
+            _parse_pattern("pattern"),
+            (None, None, 'pattern')
+        )
+        self.assertEqual(
+            _parse_pattern("/start/:pattern"),
+            ('start', None, 'pattern')
+        )
+        self.assertEqual(
+            _parse_pattern(":/end/  pattern"),
+            (None, 'end', 'pattern')
+        )
+        self.assertEqual(
+            _parse_pattern("/start/:/end/  pattern"),
+            ('start', 'end', 'pattern')
+        )
+        self.assertEqual(
+            _parse_pattern("/start/:/end/pattern"),
+            ('start', 'end', 'pattern')
+        )

.venv/lib/python3.12/site-packages/Cython/Tests/__init__.py

@@ -0,0 +1 @@
+# empty file

.venv/lib/python3.12/site-packages/Cython/Tests/xmlrunner.py

@@ -0,0 +1,395 @@
+# -*- coding: utf-8 -*-
+
+"""unittest-xml-reporting is a PyUnit-based TestRunner that can export test
+results to XML files that can be consumed by a wide range of tools, such as
+build systems, IDEs and Continuous Integration servers.
+
+This module provides the XMLTestRunner class, which is heavily based on the
+default TextTestRunner. This makes the XMLTestRunner very simple to use.
+
+The script below, adapted from the unittest documentation, shows how to use
+XMLTestRunner in a very simple way. In fact, the only difference between this
+script and the original one is the last line:
+
+import random
+import unittest
+import xmlrunner
+
+class TestSequenceFunctions(unittest.TestCase):
+    def setUp(self):
+        self.seq = range(10)
+
+    def test_shuffle(self):
+        # make sure the shuffled sequence does not lose any elements
+        random.shuffle(self.seq)
+        self.seq.sort()
+        self.assertEqual(self.seq, range(10))
+
+    def test_choice(self):
+        element = random.choice(self.seq)
+        self.assertTrue(element in self.seq)
+
+    def test_sample(self):
+        self.assertRaises(ValueError, random.sample, self.seq, 20)
+        for element in random.sample(self.seq, 5):
+            self.assertTrue(element in self.seq)
+
+if __name__ == '__main__':
+    unittest.main(testRunner=xmlrunner.XMLTestRunner(output='test-reports'))
+"""
+
+from __future__ import absolute_import
+
+import os
+import sys
+import time
+from unittest import TestResult, TextTestResult, TextTestRunner
+import xml.dom.minidom
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO  # doesn't accept 'str' in Py2
+
+
+class XMLDocument(xml.dom.minidom.Document):
+    def createCDATAOrText(self, data):
+        if ']]>' in data:
+            return self.createTextNode(data)
+        return self.createCDATASection(data)
+
+
+class _TestInfo(object):
+    """This class is used to keep useful information about the execution of a
+    test method.
+    """
+
+    # Possible test outcomes
+    (SUCCESS, FAILURE, ERROR) = range(3)
+
+    def __init__(self, test_result, test_method, outcome=SUCCESS, err=None):
+        "Create a new instance of _TestInfo."
+        self.test_result = test_result
+        self.test_method = test_method
+        self.outcome = outcome
+        self.err = err
+        self.stdout = test_result.stdout and test_result.stdout.getvalue().strip() or ''
+        self.stderr = test_result.stdout and test_result.stderr.getvalue().strip() or ''
+
+    def get_elapsed_time(self):
+        """Return the time that shows how long the test method took to
+        execute.
+        """
+        return self.test_result.stop_time - self.test_result.start_time
+
+    def get_description(self):
+        "Return a text representation of the test method."
+        return self.test_result.getDescription(self.test_method)
+
+    def get_error_info(self):
+        """Return a text representation of an exception thrown by a test
+        method.
+        """
+        if not self.err:
+            return ''
+        return self.test_result._exc_info_to_string(
+            self.err, self.test_method)
+
+
+class _XMLTestResult(TextTestResult):
+    """A test result class that can express test results in a XML report.
+
+    Used by XMLTestRunner.
+    """
+    def __init__(self, stream=sys.stderr, descriptions=1, verbosity=1,
+                 elapsed_times=True):
+        "Create a new instance of _XMLTestResult."
+        TextTestResult.__init__(self, stream, descriptions, verbosity)
+        self.successes = []
+        self.callback = None
+        self.elapsed_times = elapsed_times
+        self.output_patched = False
+
+    def _prepare_callback(self, test_info, target_list, verbose_str, short_str):
+        """Append a _TestInfo to the given target list and sets a callback
+        method to be called by stopTest method.
+        """
+        target_list.append(test_info)
+        def callback():
+            """This callback prints the test method outcome to the stream,
+            as well as the elapsed time.
+            """
+
+            # Ignore the elapsed times for a more reliable unit testing
+            if not self.elapsed_times:
+                self.start_time = self.stop_time = 0
+
+            if self.showAll:
+                self.stream.writeln('(%.3fs) %s' %
+                    (test_info.get_elapsed_time(), verbose_str))
+            elif self.dots:
+                self.stream.write(short_str)
+        self.callback = callback
+
+    def _patch_standard_output(self):
+        """Replace the stdout and stderr streams with string-based streams
+        in order to capture the tests' output.
+        """
+        if not self.output_patched:
+            (self.old_stdout, self.old_stderr) = (sys.stdout, sys.stderr)
+            self.output_patched = True
+        (sys.stdout, sys.stderr) = (self.stdout, self.stderr) = \
+            (StringIO(), StringIO())
+
+    def _restore_standard_output(self):
+        "Restore the stdout and stderr streams."
+        (sys.stdout, sys.stderr) = (self.old_stdout, self.old_stderr)
+        self.output_patched = False
+
+    def startTest(self, test):
+        "Called before execute each test method."
+        self._patch_standard_output()
+        self.start_time = time.time()
+        TestResult.startTest(self, test)
+
+        if self.showAll:
+            self.stream.write('  ' + self.getDescription(test))
+            self.stream.write(" ... ")
+
+    def stopTest(self, test):
+        "Called after execute each test method."
+        self._restore_standard_output()
+        TextTestResult.stopTest(self, test)
+        self.stop_time = time.time()
+
+        if self.callback and callable(self.callback):
+            self.callback()
+            self.callback = None
+
+    def addSuccess(self, test):
+        "Called when a test executes successfully."
+        self._prepare_callback(_TestInfo(self, test),
+                               self.successes, 'OK', '.')
+
+    def addFailure(self, test, err):
+        "Called when a test method fails."
+        self._prepare_callback(_TestInfo(self, test, _TestInfo.FAILURE, err),
+                               self.failures, 'FAIL', 'F')
+
+    def addError(self, test, err):
+        "Called when a test method raises an error."
+        self._prepare_callback(_TestInfo(self, test, _TestInfo.ERROR, err),
+                               self.errors, 'ERROR', 'E')
+
+    def printErrorList(self, flavour, errors):
+        "Write some information about the FAIL or ERROR to the stream."
+        for test_info in errors:
+            if isinstance(test_info, tuple):
+                test_info, exc_info = test_info
+
+            try:
+                t = test_info.get_elapsed_time()
+            except AttributeError:
+                t = 0
+            try:
+                descr = test_info.get_description()
+            except AttributeError:
+                try:
+                    descr = test_info.getDescription()
+                except AttributeError:
+                    descr = str(test_info)
+            try:
+                err_info = test_info.get_error_info()
+            except AttributeError:
+                err_info = str(test_info)
+
+            self.stream.writeln(self.separator1)
+            self.stream.writeln('%s [%.3fs]: %s' % (flavour, t, descr))
+            self.stream.writeln(self.separator2)
+            self.stream.writeln('%s' % err_info)
+
+    def _get_info_by_testcase(self):
+        """This method organizes test results by TestCase module. This
+        information is used during the report generation, where a XML report
+        will be generated for each TestCase.
+        """
+        tests_by_testcase = {}
+
+        for tests in (self.successes, self.failures, self.errors):
+            for test_info in tests:
+                if not isinstance(test_info, _TestInfo):
+                    print("Unexpected test result type: %r" % (test_info,))
+                    continue
+                testcase = type(test_info.test_method)
+
+                # Ignore module name if it is '__main__'
+                module = testcase.__module__ + '.'
+                if module == '__main__.':
+                    module = ''
+                testcase_name = module + testcase.__name__
+
+                if testcase_name not in tests_by_testcase:
+                    tests_by_testcase[testcase_name] = []
+                tests_by_testcase[testcase_name].append(test_info)
+
+        return tests_by_testcase
+
+    def _report_testsuite(suite_name, tests, xml_document):
+        "Appends the testsuite section to the XML document."
+        testsuite = xml_document.createElement('testsuite')
+        xml_document.appendChild(testsuite)
+
+        testsuite.setAttribute('name', str(suite_name))
+        testsuite.setAttribute('tests', str(len(tests)))
+
+        testsuite.setAttribute('time', '%.3f' %
+            sum([e.get_elapsed_time() for e in tests]))
+
+        failures = len([1 for e in tests if e.outcome == _TestInfo.FAILURE])
+        testsuite.setAttribute('failures', str(failures))
+
+        errors = len([1 for e in tests if e.outcome == _TestInfo.ERROR])
+        testsuite.setAttribute('errors', str(errors))
+
+        return testsuite
+
+    _report_testsuite = staticmethod(_report_testsuite)
+
+    def _report_testcase(suite_name, test_result, xml_testsuite, xml_document):
+        "Appends a testcase section to the XML document."
+        testcase = xml_document.createElement('testcase')
+        xml_testsuite.appendChild(testcase)
+
+        testcase.setAttribute('classname', str(suite_name))
+        testcase.setAttribute('name', test_result.test_method.shortDescription()
+                              or getattr(test_result.test_method, '_testMethodName',
+                                         str(test_result.test_method)))
+        testcase.setAttribute('time', '%.3f' % test_result.get_elapsed_time())
+
+        if (test_result.outcome != _TestInfo.SUCCESS):
+            elem_name = ('failure', 'error')[test_result.outcome-1]
+            failure = xml_document.createElement(elem_name)
+            testcase.appendChild(failure)
+
+            failure.setAttribute('type', str(test_result.err[0].__name__))
+            failure.setAttribute('message', str(test_result.err[1]))
+
+            error_info = test_result.get_error_info()
+            failureText = xml_document.createCDATAOrText(error_info)
+            failure.appendChild(failureText)
+
+    _report_testcase = staticmethod(_report_testcase)
+
+    def _report_output(test_runner, xml_testsuite, xml_document, stdout, stderr):
+        "Appends the system-out and system-err sections to the XML document."
+        systemout = xml_document.createElement('system-out')
+        xml_testsuite.appendChild(systemout)
+
+        systemout_text = xml_document.createCDATAOrText(stdout)
+        systemout.appendChild(systemout_text)
+
+        systemerr = xml_document.createElement('system-err')
+        xml_testsuite.appendChild(systemerr)
+
+        systemerr_text = xml_document.createCDATAOrText(stderr)
+        systemerr.appendChild(systemerr_text)
+
+    _report_output = staticmethod(_report_output)
+
+    def generate_reports(self, test_runner):
+        "Generates the XML reports to a given XMLTestRunner object."
+        all_results = self._get_info_by_testcase()
+
+        if isinstance(test_runner.output, str) and not os.path.exists(test_runner.output):
+            os.makedirs(test_runner.output)
+
+        for suite, tests in all_results.items():
+            doc = XMLDocument()
+
+            # Build the XML file
+            testsuite = _XMLTestResult._report_testsuite(suite, tests, doc)
+            stdout, stderr = [], []
+            for test in tests:
+                _XMLTestResult._report_testcase(suite, test, testsuite, doc)
+                if test.stdout:
+                    stdout.extend(['*****************', test.get_description(), test.stdout])
+                if test.stderr:
+                    stderr.extend(['*****************', test.get_description(), test.stderr])
+            _XMLTestResult._report_output(test_runner, testsuite, doc,
+                                          '\n'.join(stdout), '\n'.join(stderr))
+            xml_content = doc.toprettyxml(indent='\t')
+
+            if type(test_runner.output) is str:
+                report_file = open('%s%sTEST-%s.xml' %
+                    (test_runner.output, os.sep, suite), 'w')
+                try:
+                    report_file.write(xml_content)
+                finally:
+                    report_file.close()
+            else:
+                # Assume that test_runner.output is a stream
+                test_runner.output.write(xml_content)
+
+
+class XMLTestRunner(TextTestRunner):
+    """A test runner class that outputs the results in JUnit like XML files.
+    """
+    def __init__(self, output='.', stream=None, descriptions=True, verbose=False, elapsed_times=True):
+        "Create a new instance of XMLTestRunner."
+        if stream is None:
+            stream = sys.stderr
+        verbosity = (1, 2)[verbose]
+        TextTestRunner.__init__(self, stream, descriptions, verbosity)
+        self.output = output
+        self.elapsed_times = elapsed_times
+
+    def _make_result(self):
+        """Create the TestResult object which will be used to store
+        information about the executed tests.
+        """
+        return _XMLTestResult(self.stream, self.descriptions,
+            self.verbosity, self.elapsed_times)
+
+    def run(self, test):
+        "Run the given test case or test suite."
+        # Prepare the test execution
+        result = self._make_result()
+
+        # Print a nice header
+        self.stream.writeln()
+        self.stream.writeln('Running tests...')
+        self.stream.writeln(result.separator2)
+
+        # Execute tests
+        start_time = time.time()
+        test(result)
+        stop_time = time.time()
+        time_taken = stop_time - start_time
+
+        # Generate reports
+        self.stream.writeln()
+        self.stream.writeln('Generating XML reports...')
+        result.generate_reports(self)
+
+        # Print results
+        result.printErrors()
+        self.stream.writeln(result.separator2)
+        run = result.testsRun
+        self.stream.writeln("Ran %d test%s in %.3fs" %
+            (run, run != 1 and "s" or "", time_taken))
+        self.stream.writeln()
+
+        # Error traces
+        if not result.wasSuccessful():
+            self.stream.write("FAILED (")
+            failed, errored = (len(result.failures), len(result.errors))
+            if failed:
+                self.stream.write("failures=%d" % failed)
+            if errored:
+                if failed:
+                    self.stream.write(", ")
+                self.stream.write("errors=%d" % errored)
+            self.stream.writeln(")")
+        else:
+            self.stream.writeln("OK")
+
+        return result