Cython 3.1.0a1__py3-none-any.whl

Cython/Build/Tests/TestInline.py

@@ -0,0 +1,112 @@
+import os
+import tempfile
+import unittest
+from Cython.Shadow import inline
+from Cython.Build.Inline import safe_type
+from Cython.TestUtils import CythonTest
+
+try:
+    import numpy
+    has_numpy = True
+except:
+    has_numpy = False
+
+test_kwds = dict(force=True, quiet=True)
+
+global_value = 100
+
+class TestInline(CythonTest):
+    def setUp(self):
+        CythonTest.setUp(self)
+        self._call_kwds = dict(test_kwds)
+        if os.path.isdir('TEST_TMP'):
+            lib_dir = os.path.join('TEST_TMP','inline')
+        else:
+            lib_dir = tempfile.mkdtemp(prefix='cython_inline_')
+        self._call_kwds['lib_dir'] = lib_dir
+
+    def test_simple(self):
+        self.assertEqual(inline("return 1+2", **self._call_kwds), 3)
+
+    def test_types(self):
+        self.assertEqual(inline("""
+            cimport cython
+            return cython.typeof(a), cython.typeof(b)
+        """, a=1.0, b=[], **self._call_kwds), ('double', 'list object'))
+
+    def test_locals(self):
+        a = 1
+        b = 2
+        self.assertEqual(inline("return a+b", **self._call_kwds), 3)
+
+    def test_globals(self):
+        self.assertEqual(inline("return global_value + 1", **self._call_kwds), global_value + 1)
+
+    def test_no_return(self):
+        self.assertEqual(inline("""
+            a = 1
+            cdef double b = 2
+            cdef c = []
+        """, **self._call_kwds), dict(a=1, b=2.0, c=[]))
+
+    def test_def_node(self):
+        foo = inline("def foo(x): return x * x", **self._call_kwds)['foo']
+        self.assertEqual(foo(7), 49)
+
+    def test_class_ref(self):
+        class Type:
+            pass
+        tp = inline("Type")['Type']
+        self.assertEqual(tp, Type)
+
+    def test_pure(self):
+        import cython as cy
+        b = inline("""
+        b = cy.declare(float, a)
+        c = cy.declare(cy.pointer(cy.float), &b)
+        return b
+        """, a=3, **self._call_kwds)
+        self.assertEqual(type(b), float)
+
+    def test_compiler_directives(self):
+        self.assertEqual(
+            inline('return sum(x)',
+                   x=[1, 2, 3],
+                   cython_compiler_directives={'boundscheck': False}),
+            6
+        )
+
+    def test_lang_version(self):
+        # GH-3419. Caching for inline code didn't always respect compiler directives.
+        inline_divcode = "def f(int a, int b): return a/b"
+        self.assertEqual(
+            inline(inline_divcode, language_level=2)['f'](5,2),
+            2
+        )
+        self.assertEqual(
+            inline(inline_divcode, language_level=3)['f'](5,2),
+            2.5
+        )
+        self.assertEqual(
+            inline(inline_divcode, language_level=2)['f'](5,2),
+            2
+        )
+
+    def test_repeated_use(self):
+        inline_mulcode = "def f(int a, int b): return a * b"
+        self.assertEqual(inline(inline_mulcode)['f'](5, 2), 10)
+        self.assertEqual(inline(inline_mulcode)['f'](5, 3), 15)
+        self.assertEqual(inline(inline_mulcode)['f'](6, 2), 12)
+        self.assertEqual(inline(inline_mulcode)['f'](5, 2), 10)
+
+        f = inline(inline_mulcode)['f']
+        self.assertEqual(f(5, 2), 10)
+        self.assertEqual(f(5, 3), 15)
+
+    @unittest.skipIf(not has_numpy, "NumPy is not available")
+    def test_numpy(self):
+        import numpy
+        a = numpy.ndarray((10, 20))
+        a[0,0] = 10
+        self.assertEqual(safe_type(a), 'numpy.ndarray[numpy.float64_t, ndim=2]')
+        self.assertEqual(inline("return a[0,0]", a=a, **self._call_kwds), 10.0)

Cython/Build/Tests/TestIpythonMagic.py

@@ -0,0 +1,287 @@
+# tag: ipython
+
+"""Tests for the Cython magics extension."""
+
+
+import os
+import io
+import sys
+from contextlib import contextmanager
+from unittest import skipIf
+
+from Cython.Build import IpythonMagic
+from Cython.TestUtils import CythonTest
+from Cython.Compiler.Annotate import AnnotationCCodeWriter
+
+try:
+    import IPython.testing.globalipapp
+except ImportError:
+    # Disable tests and fake helpers for initialisation below.
+    def skip_if_not_installed(_):
+        return None
+else:
+    def skip_if_not_installed(c):
+        return c
+
+# not using IPython's decorators here because they depend on "nose"
+skip_win32 = skipIf(sys.platform == 'win32', "Skip on Windows")
+
+try:
+    # disable IPython history thread before it gets started to avoid having to clean it up
+    from IPython.core.history import HistoryManager
+    HistoryManager.enabled = False
+except ImportError:
+    pass
+
+
+@contextmanager
+def capture_output():
+    backup = sys.stdout, sys.stderr
+    try:
+        replacement = [
+             io.TextIOWrapper(io.BytesIO(), encoding=sys.stdout.encoding),
+             io.TextIOWrapper(io.BytesIO(), encoding=sys.stderr.encoding),
+        ]
+        sys.stdout, sys.stderr = replacement
+        output = []
+        yield output
+    finally:
+        sys.stdout, sys.stderr = backup
+        for wrapper in replacement:
+            wrapper.seek(0)  # rewind
+            output.append(wrapper.read())
+            wrapper.close()
+
+
+code = """\
+def f(x):
+    return 2*x
+"""
+
+cython3_code = """\
+def f(int x):
+    return 2 / x
+
+def call(x):
+    return f(*(x,))
+"""
+
+pgo_cython3_code = cython3_code + """\
+def main():
+    for _ in range(100): call(5)
+main()
+"""
+
+compile_error_code = '''\
+cdef extern from *:
+    """
+    xxx a=1;
+    """
+    int a;
+def doit():
+    return a
+'''
+
+compile_warning_code = '''\
+cdef extern from *:
+    """
+    #pragma message ( "CWarning" )
+    int a = 42;
+    """
+    int a;
+def doit():
+    return a
+'''
+
+
+@skip_if_not_installed
+class TestIPythonMagic(CythonTest):
+
+    @classmethod
+    def setUpClass(cls):
+        CythonTest.setUpClass()
+        cls._ip = IPython.testing.globalipapp.get_ipython()
+
+    def setUp(self):
+        CythonTest.setUp(self)
+        self._ip.extension_manager.load_extension('cython')
+
+    def test_cython_inline(self):
+        ip = self._ip
+        ip.ex('a=10; b=20')
+        result = ip.run_cell_magic('cython_inline', '', 'return a+b')
+        self.assertEqual(result, 30)
+
+    @skip_win32
+    def test_cython_pyximport(self):
+        ip = self._ip
+        module_name = '_test_cython_pyximport'
+        ip.run_cell_magic('cython_pyximport', module_name, code)
+        ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+        ip.run_cell_magic('cython_pyximport', module_name, code)
+        ip.ex('h = f(-10)')
+        self.assertEqual(ip.user_ns['h'], -20.0)
+        try:
+            os.remove(module_name + '.pyx')
+        except OSError:
+            pass
+
+    def test_cython(self):
+        ip = self._ip
+        ip.run_cell_magic('cython', '', code)
+        ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+
+    def test_cython_name(self):
+        # The Cython module named 'mymodule' defines the function f.
+        ip = self._ip
+        ip.run_cell_magic('cython', '--name=mymodule', code)
+        # This module can now be imported in the interactive namespace.
+        ip.ex('import mymodule; g = mymodule.f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+
+    def test_cython_language_level(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '', cython3_code)
+        ip.ex('g = f(10); h = call(10)')
+        self.assertEqual(ip.user_ns['g'], 2.0 / 10.0)
+        self.assertEqual(ip.user_ns['h'], 2.0 / 10.0)
+
+    def test_cython3(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '-3', cython3_code)
+        ip.ex('g = f(10); h = call(10)')
+        self.assertEqual(ip.user_ns['g'], 2.0 / 10.0)
+        self.assertEqual(ip.user_ns['h'], 2.0 / 10.0)
+
+    def test_cython2(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '-2', cython3_code)
+        ip.ex('g = f(10); h = call(10)')
+        self.assertEqual(ip.user_ns['g'], 2 // 10)
+        self.assertEqual(ip.user_ns['h'], 2 // 10)
+
+    def test_cython_compile_error_shown(self):
+        ip = self._ip
+        with capture_output() as out:
+            ip.run_cell_magic('cython', '-3', compile_error_code)
+        captured_out, captured_err = out
+
+        # it could be that c-level output is captured by distutil-extension
+        # (and not by us) and is printed to stdout:
+        captured_all = captured_out + "\n" + captured_err
+        self.assertTrue("error" in captured_all, msg="error in " + captured_all)
+
+    def test_cython_link_error_shown(self):
+        ip = self._ip
+        with capture_output() as out:
+            ip.run_cell_magic('cython', '-3 -l=xxxxxxxx', code)
+        captured_out, captured_err = out
+
+        # it could be that c-level output is captured by distutil-extension
+        # (and not by us) and is printed to stdout:
+        captured_all = captured_out + "\n!" + captured_err
+        self.assertTrue("error" in captured_all, msg="error in " + captured_all)
+
+    def test_cython_warning_shown(self):
+        ip = self._ip
+        with capture_output() as out:
+            # force rebuild, otherwise no warning as after the first success
+            # no build step is performed
+            ip.run_cell_magic('cython', '-3 -f', compile_warning_code)
+        captured_out, captured_err = out
+
+        # check that warning was printed to stdout even if build hasn't failed
+        self.assertTrue("CWarning" in captured_out)
+
+    @skip_win32
+    def test_cython3_pgo(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '-3 --pgo', pgo_cython3_code)
+        ip.ex('g = f(10); h = call(10); main()')
+        self.assertEqual(ip.user_ns['g'], 2.0 / 10.0)
+        self.assertEqual(ip.user_ns['h'], 2.0 / 10.0)
+
+    @skip_win32
+    def test_extlibs(self):
+        ip = self._ip
+        code = """
+from libc.math cimport sin
+x = sin(0.0)
+        """
+        ip.user_ns['x'] = 1
+        ip.run_cell_magic('cython', '-l m', code)
+        self.assertEqual(ip.user_ns['x'], 0)
+
+
+    def test_cython_verbose(self):
+        ip = self._ip
+        ip.run_cell_magic('cython', '--verbose', code)
+        ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+
+    def test_cython_verbose_thresholds(self):
+        @contextmanager
+        def mock_distutils():
+            class MockLog:
+                DEBUG = 1
+                INFO = 2
+                thresholds = [INFO]
+
+                def set_threshold(self, val):
+                    self.thresholds.append(val)
+                    return self.thresholds[-2]
+
+
+            new_log = MockLog()
+            old_log = IpythonMagic.distutils.log
+            try:
+                IpythonMagic.distutils.log = new_log
+                yield new_log
+            finally:
+                IpythonMagic.distutils.log = old_log
+
+        ip = self._ip
+        with mock_distutils() as verbose_log:
+            ip.run_cell_magic('cython', '--verbose', code)
+            ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+        self.assertEqual([verbose_log.INFO, verbose_log.DEBUG, verbose_log.INFO],
+                          verbose_log.thresholds)
+
+        with mock_distutils() as normal_log:
+            ip.run_cell_magic('cython', '', code)
+            ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+        self.assertEqual([normal_log.INFO], normal_log.thresholds)
+
+    def test_cython_no_annotate(self):
+        ip = self._ip
+        html = ip.run_cell_magic('cython', '', code)
+        self.assertTrue(html is None)
+
+    def test_cython_annotate(self):
+        ip = self._ip
+        html = ip.run_cell_magic('cython', '--annotate', code)
+        # somewhat brittle way to differentiate between annotated htmls
+        # with/without complete source code:
+        self.assertTrue(AnnotationCCodeWriter.COMPLETE_CODE_TITLE not in html.data)
+
+    def test_cython_annotate_default(self):
+        ip = self._ip
+        html = ip.run_cell_magic('cython', '-a', code)
+        # somewhat brittle way to differentiate between annotated htmls
+        # with/without complete source code:
+        self.assertTrue(AnnotationCCodeWriter.COMPLETE_CODE_TITLE not in html.data)
+
+    def test_cython_annotate_complete_c_code(self):
+        ip = self._ip
+        html = ip.run_cell_magic('cython', '--annotate-fullc', code)
+        # somewhat brittle way to differentiate between annotated htmls
+        # with/without complete source code:
+        self.assertTrue(AnnotationCCodeWriter.COMPLETE_CODE_TITLE in html.data)

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)