Cython 3.2.0__cp39-abi3-win32.whl

Cython/Compiler/Tests/TestTypes.py

@@ -0,0 +1,75 @@
+import unittest
+
+import Cython.Compiler.PyrexTypes as PT
+
+
+class TestMethodDispatcherTransform(unittest.TestCase):
+
+    def test_widest_numeric_type(self):
+        def assert_widest(type1, type2, widest):
+            self.assertEqual(widest, PT.widest_numeric_type(type1, type2))
+
+        assert_widest(PT.c_int_type, PT.c_long_type, PT.c_long_type)
+        assert_widest(PT.c_double_type, PT.c_long_type, PT.c_double_type)
+        assert_widest(PT.c_longdouble_type, PT.c_long_type, PT.c_longdouble_type)
+
+        cenum = PT.CEnumType("E", "cenum", typedef_flag=False)
+        assert_widest(PT.c_int_type, cenum, PT.c_int_type)
+
+
+class TestTypeIdentifiers(unittest.TestCase):
+
+    TEST_DATA = [
+        ("char*", "char__ptr"),
+        ("char *", "char__ptr"),
+        ("char **", "char__ptr__ptr"),
+        ("_typedef", "_typedef"),
+        ("__typedef", "__dundertypedef"),
+        ("___typedef", "__dunder_typedef"),
+        ("____typedef", "__dunder__dundertypedef"),
+        ("_____typedef", "__dunder__dunder_typedef"),
+        ("const __typedef", "__const___dundertypedef"),
+        ("int[42]", "int__lArr42__rArr"),
+        ("int[:]", "int__lArr__D__rArr"),
+        ("int[:,:]", "int__lArr__D__comma___D__rArr"),
+        ("int[:,:,:]", "int__lArr__D__comma___D__comma___D__rArr"),
+        ("int[:,:,...]", "int__lArr__D__comma___D__comma___EL__rArr"),
+        ("std::vector", "std__in_vector"),
+        ("std::vector&&", "std__in_vector__fwref"),
+        ("const std::vector", "__const_std__in_vector"),
+        ("const std::vector&", "__const_std__in_vector__ref"),
+        ("const_std", "const_std"),
+    ]
+
+    def test_escape_special_type_characters(self):
+        test_func = PT._escape_special_type_characters  # keep test usage visible for IDEs
+        function_name = "_escape_special_type_characters"
+        self._test_escape(function_name)
+
+    def test_type_identifier_for_declaration(self):
+        test_func = PT.type_identifier_from_declaration  # keep test usage visible for IDEs
+        function_name = test_func.__name__
+        self._test_escape(function_name)
+
+        # differences due to whitespace removal
+        test_data = [
+            ("const &std::vector", "const__refstd__in_vector"),
+            ("const &std::vector<int>", "const__refstd__in_vector__lAngint__rAng"),
+            ("const &&std::vector", "const__fwrefstd__in_vector"),
+            ("const &&&std::vector", "const__fwref__refstd__in_vector"),
+            ("const &&std::vector", "const__fwrefstd__in_vector"),
+            ("void (*func)(int x, float y)",
+             "975d51__void__lParen__ptrfunc__rParen__lParenint__spac__etc"),
+            ("float ** (*func)(int x, int[:] y)",
+             "31883a__float__ptr__ptr__lParen__ptrfunc__rParen__lPar__etc"),
+        ]
+        self._test_escape(function_name, test_data)
+
+    def _test_escape(self, func_name, test_data=TEST_DATA):
+        escape = getattr(PT, func_name)
+        for declaration, expected in test_data:
+            escaped_value = escape(declaration)
+            self.assertEqual(escaped_value, expected, "%s('%s') == '%s' != '%s'" % (
+                func_name, declaration, escaped_value, expected))
+            # test that the length has been successfully capped
+            self.assertLessEqual(len(escaped_value), 64)

Cython/Compiler/Tests/TestUtilityLoad.py

@@ -0,0 +1,112 @@
+import unittest
+
+from Cython.Compiler import Code, UtilityCode
+
+
+def strip_2tup(tup):
+    return tup[0] and tup[0].strip(), tup[1] and tup[1].strip()
+
+class TestUtilityLoader(unittest.TestCase):
+    """
+    Test loading UtilityCodes
+    """
+
+    expected = "test {{loader}} prototype", "test {{loader}} impl"
+
+    required = "req {{loader}} proto", "req {{loader}} impl"
+
+    context = dict(loader='Loader')
+
+    name = "TestUtilityLoader"
+    filename = "TestUtilityLoader.c"
+    cls = Code.UtilityCode
+
+    def test_load_as_string(self):
+        got = strip_2tup(self.cls.load_as_string(self.name, self.filename))
+        self.assertEqual(got, self.expected)
+
+    def test_load(self):
+        utility = self.cls.load(self.name, from_file=self.filename)
+        got = strip_2tup((utility.proto, utility.impl))
+        self.assertEqual(got, self.expected)
+
+        required, = utility.requires
+        got = strip_2tup((required.proto, required.impl))
+        self.assertEqual(got, self.required)
+
+        utility = self.cls.load_cached(self.name, from_file=self.filename)
+        got = strip_2tup((utility.proto, utility.impl))
+        self.assertEqual(got, self.expected)
+
+
+class TestTempitaUtilityLoader(TestUtilityLoader):
+    """
+    Test loading UtilityCodes with Tempita substitution
+    """
+    expected_tempita = (TestUtilityLoader.expected[0].replace('{{loader}}', 'Loader'),
+                        TestUtilityLoader.expected[1].replace('{{loader}}', 'Loader'))
+
+    required_tempita = (TestUtilityLoader.required[0].replace('{{loader}}', 'Loader'),
+                        TestUtilityLoader.required[1].replace('{{loader}}', 'Loader'))
+
+    cls = Code.TempitaUtilityCode
+
+    def test_load_as_string(self):
+        got = strip_2tup(self.cls.load_as_string(self.name, self.filename, context=self.context))
+        self.assertEqual(got, self.expected_tempita)
+
+    def test_load(self):
+        utility = self.cls.load(self.name, self.filename, context=self.context)
+        got = strip_2tup((utility.proto, utility.impl))
+        self.assertEqual(got, self.expected_tempita)
+
+        required, = utility.requires
+        got = strip_2tup((required.proto, required.impl))
+        self.assertEqual(got, self.required_tempita)
+
+        utility = self.cls.load(self.name, from_file=self.filename, context=self.context)
+        got = strip_2tup((utility.proto, utility.impl))
+        self.assertEqual(got, self.expected_tempita)
+
+
+class TestCythonUtilityLoader(TestTempitaUtilityLoader):
+    """
+    Test loading CythonUtilityCodes
+    """
+
+    # Just change the attributes and run the same tests
+    expected = None, "test {{cy_loader}} impl"
+    expected_tempita = None, "test CyLoader impl"
+
+    required = None, "req {{cy_loader}} impl"
+    required_tempita = None, "req CyLoader impl"
+
+    context = dict(cy_loader='CyLoader')
+
+    name = "TestCyUtilityLoader"
+    filename = "TestCyUtilityLoader.pyx"
+    cls = UtilityCode.CythonUtilityCode
+
+    # Small hack to pass our tests above
+    cls.proto = None
+
+    test_load = TestUtilityLoader.test_load
+    test_load_tempita = TestTempitaUtilityLoader.test_load
+
+
+class TestUtilityCode(unittest.TestCase):
+    def test_equality(self):
+        c1 = Code.UtilityCode.load("NumpyImportUFunc", "NumpyImportArray.c")
+        c2 = Code.UtilityCode.load("NumpyImportArray", "NumpyImportArray.c")
+        c3 = Code.UtilityCode.load("pyunicode_strlen", "StringTools.c")
+        c4 = Code.UtilityCode.load("pyunicode_from_unicode", "StringTools.c")
+        c5 = Code.UtilityCode.load("IncludeStringH", "StringTools.c")
+        c6 = Code.UtilityCode.load("IncludeCppStringH", "StringTools.c")
+
+        codes = [c1, c2, c3, c4, c5, c6]
+        for m in range(len(codes)):
+            for n in range(len(codes)):
+                if n == m:
+                    self.assertEqual(codes[m], codes[n])
+                else:
+                    self.assertNotEqual(codes[m], codes[n])

Cython/Compiler/Tests/TestVisitor.py

@@ -0,0 +1,61 @@
+from Cython.Compiler.ModuleNode import ModuleNode
+from Cython.Compiler.Symtab import ModuleScope
+from Cython.TestUtils import TransformTest
+from Cython.Compiler.Visitor import MethodDispatcherTransform
+from Cython.Compiler.ParseTreeTransforms import (
+    NormalizeTree, AnalyseDeclarationsTransform,
+    AnalyseExpressionsTransform, InterpretCompilerDirectives)
+
+
+class TestMethodDispatcherTransform(TransformTest):
+    _tree = None
+
+    def _build_tree(self):
+        if self._tree is None:
+            context = None
+
+            def fake_module(node):
+                scope = ModuleScope('test', None, None)
+                return ModuleNode(node.pos, doc=None, body=node,
+                                  scope=scope, full_module_name='test',
+                                  directive_comments={})
+            pipeline = [
+                fake_module,
+                NormalizeTree(context),
+                InterpretCompilerDirectives(context, {}),
+                AnalyseDeclarationsTransform(context),
+                AnalyseExpressionsTransform(context),
+            ]
+            self._tree = self.run_pipeline(pipeline, """
+                cdef bytes s = b'asdfg'
+                cdef dict d = {1:2}
+                x = s * 3
+                d.get('test')
+            """)
+        return self._tree
+
+    def test_builtin_method(self):
+        calls = [0]
+        class Test(MethodDispatcherTransform):
+            def _handle_simple_method_dict_get(self, node, func, args, unbound):
+                calls[0] += 1
+                return node
+
+        tree = self._build_tree()
+        Test(None)(tree)
+        self.assertEqual(1, calls[0])
+
+    def test_binop_method(self):
+        calls = {'bytes': 0, 'object': 0}
+        class Test(MethodDispatcherTransform):
+            def _handle_simple_method_bytes___mul__(self, node, func, args, unbound):
+                calls['bytes'] += 1
+                return node
+            def _handle_simple_method_object___mul__(self, node, func, args, unbound):
+                calls['object'] += 1
+                return node
+
+        tree = self._build_tree()
+        Test(None)(tree)
+        self.assertEqual(1, calls['bytes'])
+        self.assertEqual(0, calls['object'])

Cython/Compiler/Tests/Utils.py

@@ -0,0 +1,36 @@
+import copy
+
+from .. import Options
+
+
+def backup_Options():
+    backup = {}
+    for name, value in vars(Options).items():
+        # we need a deep copy of _directive_defaults, because they can be changed
+        if name == '_directive_defaults':
+            value = copy.deepcopy(value)
+        backup[name] = value
+    return backup
+
+
+def restore_Options(backup):
+    no_value = object()
+    for name, orig_value in backup.items():
+        if getattr(Options, name, no_value) != orig_value:
+            setattr(Options, name, orig_value)
+    # strip Options from new keys that might have been added:
+    for name in vars(Options).keys():
+        if name not in backup:
+            delattr(Options, name)
+
+
+def check_global_options(expected_options, white_list=[]):
+    """
+    returns error message of "" if check Ok
+    """
+    no_value = object()
+    for name, orig_value in expected_options.items():
+        if name not in white_list:
+            if getattr(Options, name, no_value) != orig_value:
+                return "error in option " + name
+    return ""

Cython/Compiler/Tests/__init__.py

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

Cython/Compiler/TreeFragment.py

@@ -0,0 +1,278 @@
+#
+# TreeFragments - parsing of strings to trees
+#
+
+"""
+Support for parsing strings into code trees.
+"""
+
+
+import re
+from io import StringIO
+
+from .Scanning import PyrexScanner, StringSourceDescriptor
+from .Symtab import ModuleScope
+from . import PyrexTypes
+from .Visitor import VisitorTransform
+from .Nodes import Node, StatListNode
+from .ExprNodes import NameNode
+from . import Parsing
+from . import Main
+from . import UtilNodes
+
+
+class StringParseContext(Main.Context):
+    def __init__(self, name, include_directories=None, compiler_directives=None, cpp=False):
+        if include_directories is None:
+            include_directories = []
+        if compiler_directives is None:
+            compiler_directives = {}
+        Main.Context.__init__(self, include_directories, compiler_directives, cpp=cpp, language_level='3')
+        self.module_name = name
+
+    def find_module(self, module_name, from_module=None, pos=None, need_pxd=1, absolute_fallback=True, relative_import=False):
+        if module_name not in (self.module_name, 'cython'):
+            raise AssertionError("Not yet supporting any cimports/includes from string code snippets")
+        return ModuleScope(module_name, parent_module=None, context=self)
+
+
+def parse_from_strings(name, code, pxds=None, level=None, initial_pos=None,
+                       context=None, allow_struct_enum_decorator=False,
+                       in_utility_code=False):
+    """
+    Utility method to parse a (unicode) string of code. This is mostly
+    used for internal Cython compiler purposes (creating code snippets
+    that transforms should emit, as well as unit testing).
+
+    code - a unicode string containing Cython (module-level) code
+    name - a descriptive name for the code source (to use in error messages etc.)
+    in_utility_code - used to suppress some messages from utility code. False by default
+                      because some generated code snippets like properties and dataclasses
+                      probably want to see those messages.
+
+    RETURNS
+
+    The tree, i.e. a ModuleNode. The ModuleNode's scope attribute is
+    set to the scope used when parsing.
+    """
+    if context is None:
+        context = StringParseContext(name)
+    # Since source files carry an encoding, it makes sense in this context
+    # to use a unicode string so that code fragments don't have to bother
+    # with encoding. This means that test code passed in should not have an
+    # encoding header.
+    assert isinstance(code, str), "unicode code snippets only please"
+    encoding = "UTF-8"
+
+    module_name = name
+    if initial_pos is None:
+        initial_pos = (name, 1, 0)
+    code_source = StringSourceDescriptor(name, code)
+    if in_utility_code:
+        code_source.in_utility_code = True
+
+    scope = context.find_module(module_name, pos=initial_pos, need_pxd=False)
+
+    buf = StringIO(code)
+
+    scanner = PyrexScanner(buf, code_source, source_encoding = encoding,
+                     scope = scope, context = context, initial_pos = initial_pos)
+    ctx = Parsing.Ctx(allow_struct_enum_decorator=allow_struct_enum_decorator)
+
+    if level is None:
+        tree = Parsing.p_module(scanner, 0, module_name, ctx=ctx)
+        tree.scope = scope
+        tree.is_pxd = False
+    else:
+        tree = Parsing.p_code(scanner, level=level, ctx=ctx)
+
+    tree.scope = scope
+    return tree
+
+
+class TreeCopier(VisitorTransform):
+    def visit_Node(self, node):
+        if node is None:
+            return node
+        else:
+            c = node.clone_node()
+            self.visitchildren(c)
+            return c
+
+
+class ApplyPositionAndCopy(TreeCopier):
+    def __init__(self, pos):
+        super().__init__()
+        self.pos = pos
+
+    def visit_Node(self, node):
+        copy = super().visit_Node(node)
+        copy.pos = self.pos
+        return copy
+
+
+class TemplateTransform(VisitorTransform):
+    """
+    Makes a copy of a template tree while doing substitutions.
+
+    A dictionary "substitutions" should be passed in when calling
+    the transform; mapping names to replacement nodes. Then replacement
+    happens like this:
+     - If an ExprStatNode contains a single NameNode, whose name is
+       a key in the substitutions dictionary, the ExprStatNode is
+       replaced with a copy of the tree given in the dictionary.
+       It is the responsibility of the caller that the replacement
+       node is a valid statement.
+     - If a single NameNode is otherwise encountered, it is replaced
+       if its name is listed in the substitutions dictionary in the
+       same way. It is the responsibility of the caller to make sure
+       that the replacement nodes is a valid expression.
+
+    Also a list "temps" should be passed. Any names listed will
+    be transformed into anonymous, temporary names.
+
+    Currently supported for tempnames is:
+    NameNode
+    (various function and class definition nodes etc. should be added to this)
+
+    Each replacement node gets the position of the substituted node
+    recursively applied to every member node.
+    """
+
+    temp_name_counter = 0
+
+    def __call__(self, node, substitutions, temps, pos):
+        self.substitutions = substitutions
+        self.pos = pos
+        tempmap = {}
+        temphandles = []
+        for temp in temps:
+            TemplateTransform.temp_name_counter += 1
+            handle = UtilNodes.TempHandle(PyrexTypes.py_object_type)
+            tempmap[temp] = handle
+            temphandles.append(handle)
+        self.tempmap = tempmap
+        result = super().__call__(node)
+        if temps:
+            result = UtilNodes.TempsBlockNode(self.get_pos(node),
+                                              temps=temphandles,
+                                              body=result)
+        return result
+
+    def get_pos(self, node):
+        if self.pos:
+            return self.pos
+        else:
+            return node.pos
+
+    def visit_Node(self, node):
+        if node is None:
+            return None
+        else:
+            c = node.clone_node()
+            if self.pos is not None:
+                c.pos = self.pos
+            self.visitchildren(c)
+            return c
+
+    def try_substitution(self, node, key):
+        sub = self.substitutions.get(key)
+        if sub is not None:
+            pos = self.pos
+            if pos is None: pos = node.pos
+            return ApplyPositionAndCopy(pos)(sub)
+        else:
+            return self.visit_Node(node)  # make copy as usual
+
+    def visit_NameNode(self, node):
+        temphandle = self.tempmap.get(node.name)
+        if temphandle:
+            # Replace name with temporary
+            return temphandle.ref(self.get_pos(node))
+        else:
+            return self.try_substitution(node, node.name)
+
+    def visit_ExprStatNode(self, node):
+        # If an expression-as-statement consists of only a replaceable
+        # NameNode, we replace the entire statement, not only the NameNode
+        if isinstance(node.expr, NameNode):
+            return self.try_substitution(node, node.expr.name)
+        else:
+            return self.visit_Node(node)
+
+
+def copy_code_tree(node):
+    return TreeCopier()(node)
+
+
+_match_indent = re.compile("^ *").match
+
+
+def strip_common_indent(lines):
+    """Strips empty lines and common indentation from the list of strings given in lines"""
+    # TODO: Facilitate textwrap.indent instead
+    lines = [x for x in lines if x.strip() != ""]
+    if lines:
+        minindent = min([len(_match_indent(x).group(0)) for x in lines])
+        lines = [x[minindent:] for x in lines]
+    return lines
+
+
+class TreeFragment:
+    def __init__(self, code, name=None, pxds=None, temps=None, pipeline=None, level=None, initial_pos=None):
+        if pxds is None:
+            pxds = {}
+        if temps is None:
+            temps = []
+        if pipeline is None:
+            pipeline = []
+        if not name:
+            name = "(tree fragment)"
+
+        if isinstance(code, str):
+            def fmt(x): return u"\n".join(strip_common_indent(x.split(u"\n")))
+
+            fmt_code = fmt(code)
+            fmt_pxds = {}
+            for key, value in pxds.items():
+                fmt_pxds[key] = fmt(value)
+            mod = t = parse_from_strings(name, fmt_code, fmt_pxds, level=level, initial_pos=initial_pos)
+            if level is None:
+                t = t.body  # Make sure a StatListNode is at the top
+            if not isinstance(t, StatListNode):
+                t = StatListNode(pos=mod.pos, stats=[t])
+            for transform in pipeline:
+                if transform is None:
+                    continue
+                t = transform(t)
+            self.root = t
+        elif isinstance(code, Node):
+            if pxds:
+                raise NotImplementedError()
+            self.root = code
+        else:
+            raise ValueError("Unrecognized code format (accepts unicode and Node)")
+        self.temps = temps
+
+    def copy(self):
+        return copy_code_tree(self.root)
+
+    def substitute(self, nodes=None, temps=None, pos = None):
+        if nodes is None:
+            nodes = {}
+        if temps is None:
+            temps = []
+        return TemplateTransform()(self.root,
+                                   substitutions = nodes,
+                                   temps = self.temps + temps, pos = pos)
+
+
+class SetPosTransform(VisitorTransform):
+    def __init__(self, pos):
+        super().__init__()
+        self.pos = pos
+
+    def visit_Node(self, node):
+        node.pos = self.pos
+        self.visitchildren(node)
+        return node