Cython 3.3.0a1__cp315-cp315-win_amd64.whl

Cython/Build/Tests/TestRecythonize.py

@@ -0,0 +1,212 @@
+import shutil
+import os
+import tempfile
+import time
+
+import Cython.Build.Dependencies
+import Cython.Utils
+from Cython.TestUtils import CythonTest
+
+
+def fresh_cythonize(*args, **kwargs):
+    Cython.Utils.clear_function_caches()
+    Cython.Build.Dependencies._dep_tree = None  # discard method caches
+    Cython.Build.Dependencies.cythonize(*args, **kwargs)
+
+class TestRecythonize(CythonTest):
+
+    def setUp(self):
+        CythonTest.setUp(self)
+        self.temp_dir = (
+            tempfile.mkdtemp(
+                prefix='recythonize-test',
+                dir='TEST_TMP' if os.path.isdir('TEST_TMP') else None
+            )
+        )
+
+    def tearDown(self):
+        CythonTest.tearDown(self)
+        shutil.rmtree(self.temp_dir)
+
+    def test_recythonize_pyx_on_pxd_change(self):
+
+        src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir)
+
+        a_pxd = os.path.join(src_dir, 'a.pxd')
+        a_pyx = os.path.join(src_dir, 'a.pyx')
+        a_c = os.path.join(src_dir, 'a.c')
+        dep_tree = Cython.Build.Dependencies.create_dependency_tree()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef int value\n')
+
+        with open(a_pyx, 'w') as f:
+            f.write('value = 1\n')
+
+
+        # The dependencies for "a.pyx" are "a.pxd" and "a.pyx".
+        self.assertEqual({a_pxd, a_pyx}, dep_tree.all_dependencies(a_pyx))
+
+        # Cythonize to create a.c
+        fresh_cythonize(a_pyx)
+
+        # Sleep to address coarse time-stamp precision.
+        time.sleep(1)
+
+        with open(a_c) as f:
+            a_c_contents1 = f.read()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef double value\n')
+
+        fresh_cythonize(a_pyx)
+
+        with open(a_c) as f:
+            a_c_contents2 = f.read()
+
+        self.assertTrue("__pyx_v_1a_value = 1;" in a_c_contents1)
+        self.assertFalse("__pyx_v_1a_value = 1;" in a_c_contents2)
+        self.assertTrue("__pyx_v_1a_value = 1.0;" in a_c_contents2)
+        self.assertFalse("__pyx_v_1a_value = 1.0;" in a_c_contents1)
+
+
+    def test_recythonize_py_on_pxd_change(self):
+
+        src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir)
+
+        a_pxd = os.path.join(src_dir, 'a.pxd')
+        a_py = os.path.join(src_dir, 'a.py')
+        a_c = os.path.join(src_dir, 'a.c')
+        dep_tree = Cython.Build.Dependencies.create_dependency_tree()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef int value\n')
+
+        with open(a_py, 'w') as f:
+            f.write('value = 1\n')
+
+
+        # The dependencies for "a.py" are "a.pxd" and "a.py".
+        self.assertEqual({a_pxd, a_py}, dep_tree.all_dependencies(a_py))
+
+        # Cythonize to create a.c
+        fresh_cythonize(a_py)
+
+        # Sleep to address coarse time-stamp precision.
+        time.sleep(1)
+
+        with open(a_c) as f:
+            a_c_contents1 = f.read()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef double value\n')
+
+        fresh_cythonize(a_py)
+
+        with open(a_c) as f:
+            a_c_contents2 = f.read()
+
+
+        self.assertTrue("__pyx_v_1a_value = 1;" in a_c_contents1)
+        self.assertFalse("__pyx_v_1a_value = 1;" in a_c_contents2)
+        self.assertTrue("__pyx_v_1a_value = 1.0;" in a_c_contents2)
+        self.assertFalse("__pyx_v_1a_value = 1.0;" in a_c_contents1)
+
+    def test_recythonize_pyx_on_dep_pxd_change(self):
+        src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir)
+
+        a_pxd = os.path.join(src_dir, 'a.pxd')
+        a_pyx = os.path.join(src_dir, 'a.pyx')
+        b_pyx = os.path.join(src_dir, 'b.pyx')
+        b_c = os.path.join(src_dir, 'b.c')
+        dep_tree = Cython.Build.Dependencies.create_dependency_tree()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef int value\n')
+
+        with open(a_pyx, 'w') as f:
+            f.write('value = 1\n')
+
+        with open(b_pyx, 'w') as f:
+            f.write('cimport a\n' + 'a.value = 2\n')
+
+
+        # The dependencies for "b.pyx" are "a.pxd" and "b.pyx".
+        self.assertEqual({a_pxd, b_pyx}, dep_tree.all_dependencies(b_pyx))
+
+
+        # Cythonize to create b.c
+        fresh_cythonize([a_pyx, b_pyx])
+
+        # Sleep to address coarse time-stamp precision.
+        time.sleep(1)
+
+        with open(b_c) as f:
+            b_c_contents1 = f.read()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef double value\n')
+
+        fresh_cythonize([a_pyx, b_pyx])
+
+        with open(b_c) as f:
+            b_c_contents2 = f.read()
+
+
+
+        self.assertTrue("__pyx_v_1a_value = 2;" in b_c_contents1)
+        self.assertFalse("__pyx_v_1a_value = 2;" in b_c_contents2)
+        self.assertTrue("__pyx_v_1a_value = 2.0;" in b_c_contents2)
+        self.assertFalse("__pyx_v_1a_value = 2.0;" in b_c_contents1)
+
+
+
+    def test_recythonize_py_on_dep_pxd_change(self):
+
+        src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir)
+
+        a_pxd = os.path.join(src_dir, 'a.pxd')
+        a_pyx = os.path.join(src_dir, 'a.pyx')
+        b_pxd = os.path.join(src_dir, 'b.pxd')
+        b_py = os.path.join(src_dir, 'b.py')
+        b_c = os.path.join(src_dir, 'b.c')
+        dep_tree = Cython.Build.Dependencies.create_dependency_tree()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef int value\n')
+
+        with open(a_pyx, 'w') as f:
+            f.write('value = 1\n')
+
+        with open(b_pxd, 'w') as f:
+            f.write('cimport a\n')
+
+        with open(b_py, 'w') as f:
+            f.write('a.value = 2\n')
+
+
+        # The dependencies for b.py are "a.pxd", "b.pxd" and "b.py".
+        self.assertEqual({a_pxd, b_pxd, b_py}, dep_tree.all_dependencies(b_py))
+
+
+        # Cythonize to create b.c
+        fresh_cythonize([a_pyx, b_py])
+
+        # Sleep to address coarse time-stamp precision.
+        time.sleep(1)
+
+        with open(b_c) as f:
+            b_c_contents1 = f.read()
+
+        with open(a_pxd, 'w') as f:
+            f.write('cdef double value\n')
+
+        fresh_cythonize([a_pyx, b_py])
+
+        with open(b_c) as f:
+            b_c_contents2 = f.read()
+
+        self.assertTrue("__pyx_v_1a_value = 2;" in b_c_contents1)
+        self.assertFalse("__pyx_v_1a_value = 2;" in b_c_contents2)
+        self.assertTrue("__pyx_v_1a_value = 2.0;" in b_c_contents2)
+        self.assertFalse("__pyx_v_1a_value = 2.0;" in b_c_contents1)

Cython/Build/Tests/TestStripLiterals.py

@@ -0,0 +1,155 @@
+import pathlib
+import re
+
+from ...TestUtils import TimedTest
+from ...Utils import open_source_file
+from ..Dependencies import strip_string_literals
+
+
+class TestStripLiterals(TimedTest):
+    maxDiff = None
+
+    @staticmethod
+    def _rebuild_string(stripped, literals):
+        def lookup(match):
+            return literals[match.group()]
+
+        return re.sub("__Pyx_L[0-9]+_", lookup, stripped)
+
+    def test_strip_string_literals(self):
+        def strip_equals(s, expected):
+            stripped, literals = strip_string_literals(s)
+            self.assertEqual(expected, stripped)
+
+            recovered = self._rebuild_string(stripped, literals)
+            self.assertEqual(s, recovered)
+
+        unchanged = [
+            "",
+            """abc""",
+            """123""",
+            """func(123)""",
+            """ '' """,
+            """ '''''''''''' """,
+            """ '''''''''''''' """,
+        ]
+
+        tests = [(code, code) for code in unchanged] + [
+            # strings and quotes
+            ('"x"',
+             '"__Pyx_L1_"'),
+            ("'x'",
+             "'__Pyx_L1_'"),
+            (""" '"' "'" """,
+             """ '__Pyx_L1_' "__Pyx_L2_" """),
+            (""" '''' ''' """,
+             """ '''__Pyx_L1_''' """),
+            (''' """" """ ''',
+             ''' """__Pyx_L1_""" '''),
+            (" '''a\n''' ",
+             " '''__Pyx_L1_''' "),
+
+            # escapes
+            (r"'a\'b'",
+             "'__Pyx_L1_'"),
+            (r"'a\\'",
+             "'__Pyx_L1_'"),
+            (r"'a\\\'b'",
+             "'__Pyx_L1_'"),
+
+            # string prefixes
+            ("u'abc'",
+             "u'__Pyx_L1_'"),
+            (r"r'abc\\'",
+             "r'__Pyx_L1_'"),
+            (r"ru'abc\\'",
+             "ru'__Pyx_L1_'"),
+
+            # comments
+            ("abc # foo",
+             "abc #__Pyx_L1_"),
+            ("abc # 'x'",
+             "abc #__Pyx_L1_"),
+            ("'abc#'",
+             "'__Pyx_L1_'"),
+
+            # special commands
+            ("include 'a.pxi' # something here",
+             "include '__Pyx_L1_' #__Pyx_L2_"),
+            ("cdef extern from 'a.h': # comment",
+             "cdef extern from '__Pyx_L1_': #__Pyx_L2_"),
+
+            # mixed strings
+            (""" func('xyz') + " " + "" '' # '' | "" "123" 'xyz' "' """,
+             """ func('__Pyx_L1_') + "__Pyx_L2_" + "" '' #__Pyx_L3_"""),
+
+            (""" f'f' """,
+             """ f'__Pyx_L1_' """),
+
+            (""" f'a{123}b' """,
+             """ f'__Pyx_L1_{123}__Pyx_L2_' """),
+
+            (""" f'{1}{f'xyz'}' """,
+             """ f'{1}{f'__Pyx_L1_'}' """),
+
+            (""" f'{f'''xyz{f\"""abc\"""}'''}' """,
+             """ f'{f'''__Pyx_L1_{f\"""__Pyx_L2_\"""}'''}' """),
+
+            (""" f'{{{{{"abc"}}}}}{{}}{{' == '{{abc}}{}{' """,
+             """ f'__Pyx_L1_{"__Pyx_L2_"}__Pyx_L3_' == '__Pyx_L4_' """),
+
+            ("f'" + ('{x} ' * 250) + "{x:{width}} '",
+             "f'" + ''.join([f'{{x}}__Pyx_L{n}_' for n in range(1, 251)]) + "{x:{width}}__Pyx_L251_'")
+        ]
+
+        for code, expected in tests:
+            with self.subTest(code=code):
+                strip_equals(code, expected)  # plain
+            code = code.strip()
+            expected = expected.strip()
+            with self.subTest(code=code):
+                strip_equals(code, expected)  # stripped
+            code += "\n"
+            expected += "\n"
+            with self.subTest(code=code):
+                strip_equals(code, expected)  # +EOL
+
+        # GH-5977: unclosed string literal
+        strip_equals(
+            """ print("Say something: %s' % something) """,
+            """ print("__Pyx_L1_"""
+        )
+
+    def _test_all_files(self, base_dir, file_paths):
+        _find_leftover_string = re.compile(r"""[^_'"}](['"]+)[^_'"{]""").search
+        for file_path in sorted(file_paths):
+            with self.subTest(file=str(file_path.relative_to(base_dir))):
+                with open_source_file(str(file_path)) as f:
+                    code = f.read()
+                stripped, literals = strip_string_literals(code)
+
+                match = _find_leftover_string(stripped)
+                if match and len(match.group(1)) != 2:
+                    match_pos = match.start() + 1
+                    self.fail(f"Leftover string found: {stripped[match_pos - 12 : match_pos + 12]!r}")
+
+                recovered = self._rebuild_string(stripped, literals)
+                self.assertEqual(code, recovered)
+
+    def test_strip_string_literals_py_files(self):
+        # process all .py files in the Cython package
+        package_dir = pathlib.Path(__file__).absolute().parents[2]
+        assert package_dir.name == 'Cython'
+        base_dir = package_dir.parent
+        self._test_all_files(base_dir, package_dir.rglob("*.py"))
+
+    def test_strip_string_literals_test_files(self):
+        # process all .py[x] files in the tests package
+        base_dir = pathlib.Path(__file__).absolute().parents[3]
+        tests_dir = base_dir / 'tests'
+        test_files = []
+        for test_subdir in tests_dir.iterdir():
+            if test_subdir.is_dir() and test_subdir.name != 'errors':
+                test_files.extend(test_subdir.rglob("*.py"))
+                test_files.extend(test_subdir.rglob("*.pyx"))
+        self._test_all_files(base_dir, test_files)

Cython/Build/Tests/__init__.py

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

Cython/Build/__init__.py

@@ -0,0 +1,11 @@
+from .Dependencies import cythonize
+
+__all__ = ["cythonize"]
+
+
+def __getattr__(name):
+    if name == 'build_ext':
+        # Lazy import, fails if distutils is not available (in Python 3.12+).
+        from .Distutils import build_ext
+        return build_ext
+    raise AttributeError("module '%s' has no attribute '%s'" % (__name__, name))