Cython 3.3.0a1__cp315-cp315-win_amd64.whl

Cython/Tests/TestCythonUtils.py

@@ -0,0 +1,202 @@
+import sys
+from io import StringIO
+
+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,
+)
+from Cython.TestUtils import TimedTest
+
+METHOD_NAME = "cached_next"
+CACHE_NAME = _build_cache_name(METHOD_NAME)
+NAMES = CACHE_NAME, METHOD_NAME
+
+class Cached:
+    @cached_method
+    def cached_next(self, x):
+        return next(x)
+
+
+class TestCythonUtils(TimedTest):
+    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))
+        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))
+        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))
+            )

Cython/Tests/TestJediTyper.py

@@ -0,0 +1,223 @@
+# tag: jedi
+
+
+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_CompilerDirectivesMixin(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': {'int'}, 'i': {'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': {'int'}, 'i': {'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': {'float', 'int', 'str'}, 'b': {'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': {'int'}, 'i': {'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': {'list'}, 'b': {'list'}, 'c': {'list'}, 'd': {'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': {'list'}, 'b': {'list'}, 'c': {'list'}, 'x': {'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': {'dict'}, 'b': {'dict'}, 'c': {'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': {'dict'}, 'b': {'dict'}, 'c': {'dict'}, 'x': {'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'}, 'c': {'set'}, 'd': {'set'}, 'e': {'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'}, 'c': {'set'}, 'd': {'set'}, 'x': {'set'}}, variables)
+
+
+class TestTypeInjection(TestJediTyper):
+    """
+    Subtype of TestJediTyper that additionally tests type injection and compilation.
+    """
+    def setUp(self):
+        super().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

Cython/Tests/TestShadow.py

@@ -0,0 +1,110 @@
+from Cython import Shadow
+from Cython.Compiler import Options, CythonScope, PyrexTypes, Errors
+from Cython.TestUtils import TimedTest
+
+
+class TestShadow(TimedTest):
+    def tearDown(self):
+        Errors.reset()  # help out any future tests
+
+    def test_all_directives_in_shadow(self):
+        missing_directives = []
+        extra_directives = []
+        for full_directive in Options.directive_types.keys():
+            directive, *rest = full_directive.split('.')
+
+            scope = Options.directive_scopes.get(full_directive)
+            if scope and len(scope) == 1 and scope[0] == "module":
+                # module-scoped things can't be used from Cython
+                if hasattr(Shadow, directive):
+                    extra_directives.append(full_directive)
+                continue
+            if full_directive == "staticmethod":
+                # staticmethod is a weird special-case and not really intended to be
+                # used from the cython module
+                continue
+
+            if not hasattr(Shadow, directive):
+                missing_directives.append(full_directive)
+            elif rest:
+                directive_value = getattr(Shadow, directive)
+                for subdirective in rest:
+                    if (hasattr(type(directive_value), '__getattr__') or
+                            hasattr(type(directive_value), '__getattribute__')):
+                        # skip things like "dataclasses" which override attribute lookup
+                        break
+        self.assertEqual(missing_directives, [])
+        self.assertEqual(extra_directives, [])
+
+    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" that CythonScope.lookup_type can fail
+        class Context:
+            cpp = False
+            language_level = 3
+            future_directives = []
+        cython_scope._context = Context
+
+        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, [])

Cython/Tests/TestStringIOTree.py

@@ -0,0 +1,68 @@
+from Cython import StringIOTree as stringtree
+from Cython.TestUtils import TimedTest
+
+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(TimedTest):
+
+    def setUp(self):
+        self.tree = stringtree.StringIOTree()
+        super().setUp()
+
+    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')

Cython/Tests/TestTestUtils.py

@@ -0,0 +1,89 @@
+import os.path
+import tempfile
+import textwrap
+import shutil
+
+from ..TestUtils import TimedTest, write_file, write_newer_file, _parse_pattern
+
+
+class TestTestUtils(TimedTest):
+    def setUp(self):
+        super().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().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 = "abcüöä"
+        self._test_write_file(text, text.encode('utf8'))
+
+    def test_write_file_dedent(self):
+        text = """
+        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')
+        )

Cython/Tests/__init__.py

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