Add files using upload-large-folder tool

.gitattributes

@@ -395,3 +395,5 @@ tuning-competition-baseline/.venv/lib/python3.11/site-packages/nvidia/cudnn/lib/
 .venv/lib/python3.11/site-packages/mistral_common/data/mistral_instruct_tokenizer_241114.model.v7 filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/mistral_common/data/mistral_instruct_tokenizer_241114.model.v7m1 filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/mistral_common/data/tokenizer.model.v1 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/mistral_common/data/mistral_instruct_tokenizer_240216.model.v2 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numpy/lib/tests/__pycache__/test_io.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.11/site-packages/mistral_common/data/mistral_instruct_tokenizer_240216.model.v2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37f00374dea48658ee8f5d0f21895b9bc55cb0103939607c8185bfd1c6ca1f89
+size 587404

.venv/lib/python3.11/site-packages/numpy/lib/tests/__pycache__/test_io.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2010346e0e3cb10ca0cd2e7e3c16b408172831251b537634fb7f258b2742caff
+size 203055

.venv/lib/python3.11/site-packages/numpy/lib/tests/data/py3-objarr.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a534d587c7b3a7e97000addf920bdd294f00ae9e4d30ace7543f8ce84c7fb80d
+size 341

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestBuffer.py

@@ -0,0 +1,105 @@
+from Cython.TestUtils import CythonTest
+import Cython.Compiler.Errors as Errors
+from Cython.Compiler.Nodes import *
+from Cython.Compiler.ParseTreeTransforms import *
+from Cython.Compiler.Buffer import *
+
+
+class TestBufferParsing(CythonTest):
+    # First, we only test the raw parser, i.e.
+    # the number and contents of arguments are NOT checked.
+    # However "dtype"/the first positional argument is special-cased
+    #  to parse a type argument rather than an expression
+
+    def parse(self, s):
+        return self.should_not_fail(lambda: self.fragment(s)).root
+
+    def not_parseable(self, expected_error, s):
+        e = self.should_fail(lambda: self.fragment(s),  Errors.CompileError)
+        self.assertEqual(expected_error, e.message_only)
+
+    def test_basic(self):
+        t = self.parse(u"cdef object[float, 4, ndim=2, foo=foo] x")
+        bufnode = t.stats[0].base_type
+        self.assertTrue(isinstance(bufnode, TemplatedTypeNode))
+        self.assertEqual(2, len(bufnode.positional_args))
+#        print bufnode.dump()
+        # should put more here...
+
+    def test_type_pos(self):
+        self.parse(u"cdef object[short unsigned int, 3] x")
+
+    def test_type_keyword(self):
+        self.parse(u"cdef object[foo=foo, dtype=short unsigned int] x")
+
+    def test_pos_after_key(self):
+        self.not_parseable("Non-keyword arg following keyword arg",
+                           u"cdef object[foo=1, 2] x")
+
+
+# See also tests/error/e_bufaccess.pyx and tets/run/bufaccess.pyx
+# THESE TESTS ARE NOW DISABLED, the code they test was pretty much
+# refactored away
+class TestBufferOptions(CythonTest):
+    # Tests the full parsing of the options within the brackets
+
+    def nonfatal_error(self, error):
+        # We're passing self as context to transform to trap this
+        self.error = error
+        self.assertTrue(self.expect_error)
+
+    def parse_opts(self, opts, expect_error=False):
+        assert opts != ""
+        s = u"def f():\n  cdef object[%s] x" % opts
+        self.expect_error = expect_error
+        root = self.fragment(s, pipeline=[NormalizeTree(self), PostParse(self)]).root
+        if not expect_error:
+            vardef = root.stats[0].body.stats[0]
+            assert isinstance(vardef, CVarDefNode)  # use normal assert as this is to validate the test code
+            buftype = vardef.base_type
+            self.assertTrue(isinstance(buftype, TemplatedTypeNode))
+            self.assertTrue(isinstance(buftype.base_type_node, CSimpleBaseTypeNode))
+            self.assertEqual(u"object", buftype.base_type_node.name)
+            return buftype
+        else:
+            self.assertTrue(len(root.stats[0].body.stats) == 0)
+
+    def non_parse(self, expected_err, opts):
+        self.parse_opts(opts, expect_error=True)
+#        e = self.should_fail(lambda: self.parse_opts(opts))
+        self.assertEqual(expected_err, self.error.message_only)
+
+    def __test_basic(self):
+        buf = self.parse_opts(u"unsigned short int, 3")
+        self.assertTrue(isinstance(buf.dtype_node, CSimpleBaseTypeNode))
+        self.assertTrue(buf.dtype_node.signed == 0 and buf.dtype_node.longness == -1)
+        self.assertEqual(3, buf.ndim)
+
+    def __test_dict(self):
+        buf = self.parse_opts(u"ndim=3, dtype=unsigned short int")
+        self.assertTrue(isinstance(buf.dtype_node, CSimpleBaseTypeNode))
+        self.assertTrue(buf.dtype_node.signed == 0 and buf.dtype_node.longness == -1)
+        self.assertEqual(3, buf.ndim)
+
+    def __test_ndim(self):
+        self.parse_opts(u"int, 2")
+        self.non_parse(ERR_BUF_NDIM, u"int, 'a'")
+        self.non_parse(ERR_BUF_NDIM, u"int, -34")
+
+    def __test_use_DEF(self):
+        t = self.fragment(u"""
+        DEF ndim = 3
+        def f():
+            cdef object[int, ndim] x
+            cdef object[ndim=ndim, dtype=int] y
+        """, pipeline=[NormalizeTree(self), PostParse(self)]).root
+        stats = t.stats[0].body.stats
+        self.assertTrue(stats[0].base_type.ndim == 3)
+        self.assertTrue(stats[1].base_type.ndim == 3)
+
+    # add exotic and impossible combinations as they come along...
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestCmdLine.py

@@ -0,0 +1,579 @@
+import os
+import sys
+import re
+from unittest import TestCase
+try:
+    from unittest.mock import patch, Mock
+except ImportError:  # Py2
+    from mock import patch, Mock
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO  # doesn't accept 'str' in Py2
+
+from .. import Options
+from ..CmdLine import parse_command_line
+
+from .Utils import backup_Options, restore_Options, check_global_options
+
+unpatched_exists = os.path.exists
+
+def patched_exists(path):
+    # avoid the Cython command raising a file not found error
+    if path in (
+        'source.pyx',
+        os.path.join('/work/dir', 'source.pyx'),
+        os.path.join('my_working_path', 'source.pyx'),
+        'file.pyx',
+        'file1.pyx',
+        'file2.pyx',
+        'file3.pyx',
+        'foo.pyx',
+        'bar.pyx',
+    ):
+        return True
+    return unpatched_exists(path)
+
+@patch('os.path.exists', new=Mock(side_effect=patched_exists))
+class CmdLineParserTest(TestCase):
+    def setUp(self):
+        self._options_backup = backup_Options()
+
+    def tearDown(self):
+        restore_Options(self._options_backup)
+
+    def check_default_global_options(self, white_list=[]):
+        self.assertEqual(check_global_options(self._options_backup, white_list), "")
+
+    def check_default_options(self, options, white_list=[]):
+        default_options = Options.CompilationOptions(Options.default_options)
+        no_value = object()
+        for name in default_options.__dict__.keys():
+            if name not in white_list:
+                self.assertEqual(getattr(options, name, no_value), getattr(default_options, name), msg="error in option " + name)
+
+    def test_short_options(self):
+        options, sources = parse_command_line([
+            '-V', '-l', '-+', '-t', '-v', '-v', '-v', '-p', '-D', '-a', '-3',
+        ])
+        self.assertFalse(sources)
+        self.assertTrue(options.show_version)
+        self.assertTrue(options.use_listing_file)
+        self.assertTrue(options.cplus)
+        self.assertTrue(options.timestamps)
+        self.assertTrue(options.verbose >= 3)
+        self.assertTrue(Options.embed_pos_in_docstring)
+        self.assertFalse(Options.docstrings)
+        self.assertTrue(Options.annotate)
+        self.assertEqual(options.language_level, 3)
+
+        options, sources = parse_command_line([
+            '-f', '-2', 'source.pyx',
+        ])
+        self.assertTrue(sources)
+        self.assertTrue(len(sources) == 1)
+        self.assertFalse(options.timestamps)
+        self.assertEqual(options.language_level, 2)
+
+    def test_long_options(self):
+        options, sources = parse_command_line([
+            '--version', '--create-listing', '--cplus', '--embed', '--timestamps',
+            '--verbose', '--verbose', '--verbose',
+            '--embed-positions', '--no-docstrings', '--annotate', '--lenient',
+        ])
+        self.assertFalse(sources)
+        self.assertTrue(options.show_version)
+        self.assertTrue(options.use_listing_file)
+        self.assertTrue(options.cplus)
+        self.assertEqual(Options.embed, 'main')
+        self.assertTrue(options.timestamps)
+        self.assertTrue(options.verbose >= 3)
+        self.assertTrue(Options.embed_pos_in_docstring)
+        self.assertFalse(Options.docstrings)
+        self.assertTrue(Options.annotate)
+        self.assertFalse(Options.error_on_unknown_names)
+        self.assertFalse(Options.error_on_uninitialized)
+
+        options, sources = parse_command_line([
+            '--force', 'source.pyx',
+        ])
+        self.assertTrue(sources)
+        self.assertTrue(len(sources) == 1)
+        self.assertFalse(options.timestamps)
+
+    def test_options_with_values(self):
+        options, sources = parse_command_line([
+            '--embed=huhu',
+            '-I/test/include/dir1', '--include-dir=/test/include/dir2',
+            '--include-dir', '/test/include/dir3',
+            '--working=/work/dir',
+            'source.pyx',
+            '--output-file=/output/dir',
+            '--pre-import=/pre/import',
+            '--cleanup=3',
+            '--annotate-coverage=cov.xml',
+            '--gdb-outdir=/gdb/outdir',
+            '--directive=wraparound=false',
+        ])
+        self.assertEqual(sources, ['source.pyx'])
+        self.assertEqual(Options.embed, 'huhu')
+        self.assertEqual(options.include_path, ['/test/include/dir1', '/test/include/dir2', '/test/include/dir3'])
+        self.assertEqual(options.working_path, '/work/dir')
+        self.assertEqual(options.output_file, '/output/dir')
+        self.assertEqual(Options.pre_import, '/pre/import')
+        self.assertEqual(Options.generate_cleanup_code, 3)
+        self.assertTrue(Options.annotate)
+        self.assertEqual(Options.annotate_coverage_xml, 'cov.xml')
+        self.assertTrue(options.gdb_debug)
+        self.assertEqual(options.output_dir, '/gdb/outdir')
+        self.assertEqual(options.compiler_directives['wraparound'], False)
+
+    def test_embed_before_positional(self):
+        options, sources = parse_command_line([
+            '--embed',
+            'source.pyx',
+        ])
+        self.assertEqual(sources, ['source.pyx'])
+        self.assertEqual(Options.embed, 'main')
+
+    def test_two_embeds(self):
+        options, sources = parse_command_line([
+            '--embed', '--embed=huhu',
+            'source.pyx',
+        ])
+        self.assertEqual(sources, ['source.pyx'])
+        self.assertEqual(Options.embed, 'huhu')
+
+    def test_two_embeds2(self):
+        options, sources = parse_command_line([
+            '--embed=huhu', '--embed',
+            'source.pyx',
+        ])
+        self.assertEqual(sources, ['source.pyx'])
+        self.assertEqual(Options.embed, 'main')
+
+    def test_no_annotate(self):
+        options, sources = parse_command_line([
+            '--embed=huhu', 'source.pyx'
+        ])
+        self.assertFalse(Options.annotate)
+
+    def test_annotate_short(self):
+        options, sources = parse_command_line([
+            '-a',
+            'source.pyx',
+        ])
+        self.assertEqual(Options.annotate, 'default')
+
+    def test_annotate_long(self):
+        options, sources = parse_command_line([
+            '--annotate',
+            'source.pyx',
+        ])
+        self.assertEqual(Options.annotate, 'default')
+
+    def test_annotate_fullc(self):
+        options, sources = parse_command_line([
+            '--annotate-fullc',
+            'source.pyx',
+        ])
+        self.assertEqual(Options.annotate, 'fullc')
+
+    def test_short_w(self):
+        options, sources = parse_command_line([
+            '-w', 'my_working_path',
+            'source.pyx'
+        ])
+        self.assertEqual(options.working_path, 'my_working_path')
+        self.check_default_global_options()
+        self.check_default_options(options, ['working_path'])
+
+    def test_short_o(self):
+        options, sources = parse_command_line([
+            '-o', 'my_output',
+            'source.pyx'
+        ])
+        self.assertEqual(options.output_file, 'my_output')
+        self.check_default_global_options()
+        self.check_default_options(options, ['output_file'])
+
+    def test_short_z(self):
+        options, sources = parse_command_line([
+            '-z', 'my_preimport',
+            'source.pyx'
+        ])
+        self.assertEqual(Options.pre_import, 'my_preimport')
+        self.check_default_global_options(['pre_import'])
+        self.check_default_options(options)
+
+    def test_convert_range(self):
+        options, sources = parse_command_line([
+            '--convert-range',
+            'source.pyx'
+        ])
+        self.assertEqual(Options.convert_range, True)
+        self.check_default_global_options(['convert_range'])
+        self.check_default_options(options)
+
+    def test_line_directives(self):
+        options, sources = parse_command_line([
+            '--line-directives',
+            'source.pyx'
+        ])
+        self.assertEqual(options.emit_linenums, True)
+        self.check_default_global_options()
+        self.check_default_options(options, ['emit_linenums'])
+
+    def test_no_c_in_traceback(self):
+        options, sources = parse_command_line([
+            '--no-c-in-traceback',
+            'source.pyx'
+        ])
+        self.assertEqual(options.c_line_in_traceback, False)
+        self.check_default_global_options()
+        self.check_default_options(options, ['c_line_in_traceback'])
+
+    def test_gdb(self):
+        options, sources = parse_command_line([
+            '--gdb',
+            'source.pyx'
+        ])
+        self.assertEqual(options.gdb_debug, True)
+        self.assertEqual(options.output_dir, os.curdir)
+        self.check_default_global_options()
+        self.check_default_options(options, ['gdb_debug', 'output_dir'])
+
+    def test_3str(self):
+        options, sources = parse_command_line([
+            '--3str',
+            'source.pyx'
+        ])
+        self.assertEqual(options.language_level, '3str')
+        self.check_default_global_options()
+        self.check_default_options(options, ['language_level'])
+
+    def test_capi_reexport_cincludes(self):
+        options, sources = parse_command_line([
+            '--capi-reexport-cincludes',
+            'source.pyx'
+        ])
+        self.assertEqual(options.capi_reexport_cincludes, True)
+        self.check_default_global_options()
+        self.check_default_options(options, ['capi_reexport_cincludes'])
+
+    def test_fast_fail(self):
+        options, sources = parse_command_line([
+            '--fast-fail',
+            'source.pyx'
+        ])
+        self.assertEqual(Options.fast_fail, True)
+        self.check_default_global_options(['fast_fail'])
+        self.check_default_options(options)
+
+    def test_cimport_from_pyx(self):
+        options, sources = parse_command_line([
+            '--cimport-from-pyx',
+            'source.pyx'
+        ])
+        self.assertEqual(Options.cimport_from_pyx, True)
+        self.check_default_global_options(['cimport_from_pyx'])
+        self.check_default_options(options)
+
+    def test_Werror(self):
+        options, sources = parse_command_line([
+            '-Werror',
+            'source.pyx'
+        ])
+        self.assertEqual(Options.warning_errors, True)
+        self.check_default_global_options(['warning_errors'])
+        self.check_default_options(options)
+
+    def test_warning_errors(self):
+        options, sources = parse_command_line([
+            '--warning-errors',
+            'source.pyx'
+        ])
+        self.assertEqual(Options.warning_errors, True)
+        self.check_default_global_options(['warning_errors'])
+        self.check_default_options(options)
+
+    def test_Wextra(self):
+        options, sources = parse_command_line([
+            '-Wextra',
+            'source.pyx'
+        ])
+        self.assertEqual(options.compiler_directives, Options.extra_warnings)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compiler_directives'])
+
+    def test_warning_extra(self):
+        options, sources = parse_command_line([
+            '--warning-extra',
+            'source.pyx'
+        ])
+        self.assertEqual(options.compiler_directives, Options.extra_warnings)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compiler_directives'])
+
+    def test_old_style_globals(self):
+        options, sources = parse_command_line([
+            '--old-style-globals',
+            'source.pyx'
+        ])
+        self.assertEqual(Options.old_style_globals, True)
+        self.check_default_global_options(['old_style_globals'])
+        self.check_default_options(options)
+
+    def test_directive_multiple(self):
+        options, source = parse_command_line([
+               '-X', 'cdivision=True',
+               '-X', 'c_string_type=bytes',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compiler_directives['cdivision'], True)
+        self.assertEqual(options.compiler_directives['c_string_type'], 'bytes')
+        self.check_default_global_options()
+        self.check_default_options(options, ['compiler_directives'])
+
+    def test_directive_multiple_v2(self):
+        options, source = parse_command_line([
+               '-X', 'cdivision=True,c_string_type=bytes',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compiler_directives['cdivision'], True)
+        self.assertEqual(options.compiler_directives['c_string_type'], 'bytes')
+        self.check_default_global_options()
+        self.check_default_options(options, ['compiler_directives'])
+
+    def test_directive_value_yes(self):
+        options, source = parse_command_line([
+               '-X', 'cdivision=YeS',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compiler_directives['cdivision'], True)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compiler_directives'])
+
+    def test_directive_value_no(self):
+        options, source = parse_command_line([
+               '-X', 'cdivision=no',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compiler_directives['cdivision'], False)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compiler_directives'])
+
+    def test_directive_value_invalid(self):
+        self.assertRaises(ValueError, parse_command_line, [
+               '-X', 'cdivision=sadfasd',
+               'source.pyx'
+        ])
+
+    def test_directive_key_invalid(self):
+        self.assertRaises(ValueError, parse_command_line, [
+               '-X', 'abracadabra',
+               'source.pyx'
+        ])
+
+    def test_directive_no_value(self):
+        self.assertRaises(ValueError, parse_command_line, [
+               '-X', 'cdivision',
+               'source.pyx'
+        ])
+
+    def test_compile_time_env_short(self):
+        options, source = parse_command_line([
+               '-E', 'MYSIZE=10',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compile_time_env['MYSIZE'], 10)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compile_time_env'])
+
+    def test_compile_time_env_long(self):
+        options, source = parse_command_line([
+               '--compile-time-env', 'MYSIZE=10',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compile_time_env['MYSIZE'], 10)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compile_time_env'])
+
+    def test_compile_time_env_multiple(self):
+        options, source = parse_command_line([
+               '-E', 'MYSIZE=10', '-E', 'ARRSIZE=11',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compile_time_env['MYSIZE'], 10)
+        self.assertEqual(options.compile_time_env['ARRSIZE'], 11)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compile_time_env'])
+
+    def test_compile_time_env_multiple_v2(self):
+        options, source = parse_command_line([
+               '-E', 'MYSIZE=10,ARRSIZE=11',
+               'source.pyx'
+        ])
+        self.assertEqual(options.compile_time_env['MYSIZE'], 10)
+        self.assertEqual(options.compile_time_env['ARRSIZE'], 11)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compile_time_env'])
+
+    def test_option_first(self):
+        options, sources = parse_command_line(['-V', 'file.pyx'])
+        self.assertEqual(sources, ['file.pyx'])
+
+    def test_file_inbetween(self):
+        options, sources = parse_command_line(['-V', 'file.pyx', '-a'])
+        self.assertEqual(sources, ['file.pyx'])
+
+    def test_option_trailing(self):
+        options, sources = parse_command_line(['file.pyx', '-V'])
+        self.assertEqual(sources, ['file.pyx'])
+
+    def test_multiple_files(self):
+        options, sources = parse_command_line([
+             'file1.pyx', '-V',
+             'file2.pyx', '-a',
+             'file3.pyx'
+        ])
+        self.assertEqual(sources, ['file1.pyx', 'file2.pyx', 'file3.pyx'])
+
+    def test_debug_flags(self):
+        options, sources = parse_command_line([
+             '--debug-disposal-code', '--debug-coercion',
+             'file3.pyx'
+        ])
+        from Cython.Compiler import DebugFlags
+        for name in ['debug_disposal_code', 'debug_temp_alloc', 'debug_coercion']:
+            self.assertEqual(getattr(DebugFlags, name), name in ['debug_disposal_code', 'debug_coercion'])
+            setattr(DebugFlags, name, 0)  # restore original value
+
+    def test_gdb_overwrites_gdb_outdir(self):
+        options, sources = parse_command_line([
+            '--gdb-outdir=my_dir', '--gdb',
+            'file3.pyx'
+        ])
+        self.assertEqual(options.gdb_debug, True)
+        self.assertEqual(options.output_dir, os.curdir)
+        self.check_default_global_options()
+        self.check_default_options(options, ['gdb_debug', 'output_dir'])
+
+    def test_gdb_first(self):
+        options, sources = parse_command_line([
+            '--gdb', '--gdb-outdir=my_dir',
+            'file3.pyx'
+        ])
+        self.assertEqual(options.gdb_debug, True)
+        self.assertEqual(options.output_dir, 'my_dir')
+        self.check_default_global_options()
+        self.check_default_options(options, ['gdb_debug', 'output_dir'])
+
+    def test_coverage_overwrites_annotation(self):
+        options, sources = parse_command_line([
+            '--annotate-fullc', '--annotate-coverage=my.xml',
+            'file3.pyx'
+        ])
+        self.assertEqual(Options.annotate, True)
+        self.assertEqual(Options.annotate_coverage_xml, 'my.xml')
+        self.check_default_global_options(['annotate', 'annotate_coverage_xml'])
+        self.check_default_options(options)
+
+    def test_coverage_first(self):
+        options, sources = parse_command_line([
+            '--annotate-coverage=my.xml', '--annotate-fullc',
+            'file3.pyx'
+        ])
+        self.assertEqual(Options.annotate, 'fullc')
+        self.assertEqual(Options.annotate_coverage_xml, 'my.xml')
+        self.check_default_global_options(['annotate', 'annotate_coverage_xml'])
+        self.check_default_options(options)
+
+    def test_annotate_first_fullc_second(self):
+        options, sources = parse_command_line([
+            '--annotate', '--annotate-fullc',
+            'file3.pyx'
+        ])
+        self.assertEqual(Options.annotate, 'fullc')
+        self.check_default_global_options(['annotate'])
+        self.check_default_options(options)
+
+    def test_annotate_fullc_first(self):
+        options, sources = parse_command_line([
+            '--annotate-fullc', '--annotate',
+            'file3.pyx'
+        ])
+        self.assertEqual(Options.annotate, 'default')
+        self.check_default_global_options(['annotate'])
+        self.check_default_options(options)
+
+    def test_warning_extra_dont_overwrite(self):
+        options, sources = parse_command_line([
+            '-X', 'cdivision=True',
+            '--warning-extra',
+            '-X', 'c_string_type=bytes',
+            'source.pyx'
+        ])
+        self.assertTrue(len(options.compiler_directives), len(Options.extra_warnings) + 1)
+        self.check_default_global_options()
+        self.check_default_options(options, ['compiler_directives'])
+
+    def test_module_name(self):
+        options, sources = parse_command_line([
+            'source.pyx'
+        ])
+        self.assertEqual(options.module_name, None)
+        self.check_default_global_options()
+        self.check_default_options(options)
+        options, sources = parse_command_line([
+            '--module-name', 'foo.bar',
+            'source.pyx'
+        ])
+        self.assertEqual(options.module_name, 'foo.bar')
+        self.check_default_global_options()
+        self.check_default_options(options, ['module_name'])
+
+    def test_errors(self):
+        def error(args, regex=None):
+            old_stderr = sys.stderr
+            stderr = sys.stderr = StringIO()
+            try:
+                self.assertRaises(SystemExit, parse_command_line, list(args))
+            finally:
+                sys.stderr = old_stderr
+            msg = stderr.getvalue()
+            err_msg = 'Message "{}"'.format(msg.strip())
+            self.assertTrue(msg.startswith('usage: '),
+                            '%s does not start with "usage :"' % err_msg)
+            self.assertTrue(': error: ' in msg,
+                            '%s does not contain ": error :"' % err_msg)
+            if regex:
+                self.assertTrue(re.search(regex, msg),
+                                '%s does not match search "%s"' %
+                                (err_msg, regex))
+
+        error(['-1'],
+              'unknown option -1')
+        error(['-I'],
+              'argument -I/--include-dir: expected one argument')
+        error(['--version=-a'],
+              "argument -V/--version: ignored explicit argument '-a'")
+        error(['--version=--annotate=true'],
+              "argument -V/--version: ignored explicit argument "
+              "'--annotate=true'")
+        error(['--working'],
+              "argument -w/--working: expected one argument")
+        error(['--verbose=1'],
+              "argument -v/--verbose: ignored explicit argument '1'")
+        error(['--cleanup'],
+              "argument --cleanup: expected one argument")
+        error(['--debug-disposal-code-wrong-name', 'file3.pyx'],
+              "unknown option --debug-disposal-code-wrong-name")
+        error(['--module-name', 'foo.pyx'],
+              "Need at least one source file")
+        error(['--module-name', 'foo.bar'],
+              "Need at least one source file")
+        error(['--module-name', 'foo.bar', 'foo.pyx', 'bar.pyx'],
+              "Only one source file allowed when using --module-name")
+        error(['--module-name', 'foo.bar', '--timestamps', 'foo.pyx'],
+              "Cannot use --module-name with --timestamps")

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestFlowControl.py

@@ -0,0 +1,68 @@
+
+from __future__ import absolute_import
+
+from copy import deepcopy
+from unittest import TestCase
+
+from Cython.Compiler.FlowControl import (
+    NameAssignment, StaticAssignment, Argument, NameDeletion)
+
+
+class FakeType(object):
+    is_pyobject = True
+
+
+class FakeNode(object):
+    pos = ('filename.pyx', 1, 2)
+    cf_state = None
+    type = FakeType()
+
+    def infer_type(self, scope):
+        return self.type
+
+
+class FakeEntry(object):
+    type = FakeType()
+
+
+class TestGraph(TestCase):
+    def test_deepcopy(self):
+        lhs, rhs = FakeNode(), FakeNode()
+        entry = FakeEntry()
+        entry.pos = lhs.pos
+
+        name_ass = NameAssignment(lhs, rhs, entry)
+        ass = deepcopy(name_ass)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, name_ass.pos)
+        self.assertFalse(ass.is_arg)
+        self.assertFalse(ass.is_deletion)
+
+        static_ass = StaticAssignment(entry)
+        ass = deepcopy(static_ass)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, static_ass.pos)
+        self.assertFalse(ass.is_arg)
+        self.assertFalse(ass.is_deletion)
+
+        arg_ass = Argument(lhs, rhs, entry)
+        ass = deepcopy(arg_ass)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, arg_ass.pos)
+        self.assertTrue(ass.is_arg)
+        self.assertFalse(ass.is_deletion)
+
+        name_del = NameDeletion(lhs, entry)
+        ass = deepcopy(name_del)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, name_del.pos)
+        self.assertFalse(ass.is_arg)
+        self.assertTrue(ass.is_deletion)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestMemView.py

@@ -0,0 +1,71 @@
+from Cython.TestUtils import CythonTest
+import Cython.Compiler.Errors as Errors
+from Cython.Compiler.Nodes import *
+from Cython.Compiler.ParseTreeTransforms import *
+from Cython.Compiler.Buffer import *
+
+
+class TestMemviewParsing(CythonTest):
+
+    def parse(self, s):
+        return self.should_not_fail(lambda: self.fragment(s)).root
+
+    def not_parseable(self, expected_error, s):
+        e = self.should_fail(lambda: self.fragment(s),  Errors.CompileError)
+        self.assertEqual(expected_error, e.message_only)
+
+    def test_default_1dim(self):
+        self.parse(u"cdef int[:] x")
+        self.parse(u"cdef short int[:] x")
+
+    def test_default_ndim(self):
+        self.parse(u"cdef int[:,:,:,:,:] x")
+        self.parse(u"cdef unsigned long int[:,:,:,:,:] x")
+        self.parse(u"cdef unsigned int[:,:,:,:,:] x")
+
+    def test_zero_offset(self):
+        self.parse(u"cdef long double[0:] x")
+        self.parse(u"cdef int[0:] x")
+
+    def test_zero_offset_ndim(self):
+        self.parse(u"cdef int[0:,0:,0:,0:] x")
+
+    def test_def_arg(self):
+        self.parse(u"def foo(int[:,:] x): pass")
+
+    def test_cdef_arg(self):
+        self.parse(u"cdef foo(int[:,:] x): pass")
+
+    def test_general_slice(self):
+        self.parse(u'cdef float[::ptr, ::direct & contig, 0::full & strided] x')
+
+    def test_non_slice_memview(self):
+        self.not_parseable(u"An axis specification in memoryview declaration does not have a ':'.",
+                u"cdef double[:foo, bar] x")
+        self.not_parseable(u"An axis specification in memoryview declaration does not have a ':'.",
+                u"cdef double[0:foo, bar] x")
+
+    def test_basic(self):
+        t = self.parse(u"cdef int[:] x")
+        memv_node = t.stats[0].base_type
+        self.assertTrue(isinstance(memv_node, MemoryViewSliceTypeNode))
+
+    # we also test other similar declarations (buffers, anonymous C arrays)
+    # since the parsing has to distinguish between them.
+
+    def disable_test_no_buf_arg(self):  # TODO
+        self.not_parseable(u"Expected ']'",
+                u"cdef extern foo(object[int, ndim=2])")
+
+    def disable_test_parse_sizeof(self):  # TODO
+        self.parse(u"sizeof(int[NN])")
+        self.parse(u"sizeof(int[])")
+        self.parse(u"sizeof(int[][NN])")
+        self.not_parseable(u"Expected an identifier or literal",
+                u"sizeof(int[:NN])")
+        self.not_parseable(u"Expected ']'",
+                u"sizeof(foo[dtype=bar]")
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestParseTreeTransforms.py

@@ -0,0 +1,289 @@
+import os.path
+import unittest
+
+from Cython.TestUtils import TransformTest
+from Cython.Compiler.ParseTreeTransforms import *
+from Cython.Compiler.ParseTreeTransforms import _calculate_pickle_checksums
+from Cython.Compiler.Nodes import *
+from Cython.Compiler import Main, Symtab, Options
+
+
+class TestNormalizeTree(TransformTest):
+    def test_parserbehaviour_is_what_we_coded_for(self):
+        t = self.fragment(u"if x: y").root
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: ExprStatNode
+        expr: NameNode
+""", self.treetypes(t))
+
+    def test_wrap_singlestat(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"if x: y")
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: StatListNode
+        stats[0]: ExprStatNode
+          expr: NameNode
+""", self.treetypes(t))
+
+    def test_wrap_multistat(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"""
+            if z:
+                x
+                y
+        """)
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: StatListNode
+        stats[0]: ExprStatNode
+          expr: NameNode
+        stats[1]: ExprStatNode
+          expr: NameNode
+""", self.treetypes(t))
+
+    def test_statinexpr(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"""
+            a, b = x, y
+        """)
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: SingleAssignmentNode
+    lhs: TupleNode
+      args[0]: NameNode
+      args[1]: NameNode
+    rhs: TupleNode
+      args[0]: NameNode
+      args[1]: NameNode
+""", self.treetypes(t))
+
+    def test_wrap_offagain(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"""
+            x
+            y
+            if z:
+                x
+        """)
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: ExprStatNode
+    expr: NameNode
+  stats[1]: ExprStatNode
+    expr: NameNode
+  stats[2]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: StatListNode
+        stats[0]: ExprStatNode
+          expr: NameNode
+""", self.treetypes(t))
+
+
+    def test_pass_eliminated(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"pass")
+        self.assertTrue(len(t.stats) == 0)
+
+class TestWithTransform(object):  # (TransformTest): # Disabled!
+
+    def test_simplified(self):
+        t = self.run_pipeline([WithTransform(None)], u"""
+        with x:
+            y = z ** 3
+        """)
+
+        self.assertCode(u"""
+
+        $0_0 = x
+        $0_2 = $0_0.__exit__
+        $0_0.__enter__()
+        $0_1 = True
+        try:
+            try:
+                $1_0 = None
+                y = z ** 3
+            except:
+                $0_1 = False
+                if (not $0_2($1_0)):
+                    raise
+        finally:
+            if $0_1:
+                $0_2(None, None, None)
+
+        """, t)
+
+    def test_basic(self):
+        t = self.run_pipeline([WithTransform(None)], u"""
+        with x as y:
+            y = z ** 3
+        """)
+        self.assertCode(u"""
+
+        $0_0 = x
+        $0_2 = $0_0.__exit__
+        $0_3 = $0_0.__enter__()
+        $0_1 = True
+        try:
+            try:
+                $1_0 = None
+                y = $0_3
+                y = z ** 3
+            except:
+                $0_1 = False
+                if (not $0_2($1_0)):
+                    raise
+        finally:
+            if $0_1:
+                $0_2(None, None, None)
+
+        """, t)
+
+
+class TestInterpretCompilerDirectives(TransformTest):
+    """
+    This class tests the parallel directives AST-rewriting and importing.
+    """
+
+    # Test the parallel directives (c)importing
+
+    import_code = u"""
+        cimport cython.parallel
+        cimport cython.parallel as par
+        from cython cimport parallel as par2
+        from cython cimport parallel
+
+        from cython.parallel cimport threadid as tid
+        from cython.parallel cimport threadavailable as tavail
+        from cython.parallel cimport prange
+    """
+
+    expected_directives_dict = {
+        u'cython.parallel': u'cython.parallel',
+        u'par': u'cython.parallel',
+        u'par2': u'cython.parallel',
+        u'parallel': u'cython.parallel',
+
+        u"tid": u"cython.parallel.threadid",
+        u"tavail": u"cython.parallel.threadavailable",
+        u"prange": u"cython.parallel.prange",
+    }
+
+
+    def setUp(self):
+        super(TestInterpretCompilerDirectives, 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.pipeline = [transform]
+
+        self.debug_exception_on_error = DebugFlags.debug_exception_on_error
+
+    def tearDown(self):
+        DebugFlags.debug_exception_on_error = self.debug_exception_on_error
+
+    def test_parallel_directives_cimports(self):
+        self.run_pipeline(self.pipeline, self.import_code)
+        parallel_directives = self.pipeline[0].parallel_directives
+        self.assertEqual(parallel_directives, self.expected_directives_dict)
+
+    def test_parallel_directives_imports(self):
+        self.run_pipeline(self.pipeline,
+                          self.import_code.replace(u'cimport', u'import'))
+        parallel_directives = self.pipeline[0].parallel_directives
+        self.assertEqual(parallel_directives, self.expected_directives_dict)
+
+
+# TODO: Re-enable once they're more robust.
+if False:
+    from Cython.Debugger import DebugWriter
+    from Cython.Debugger.Tests.TestLibCython import DebuggerTestCase
+else:
+    # skip test, don't let it inherit unittest.TestCase
+    DebuggerTestCase = object
+
+
+class TestDebugTransform(DebuggerTestCase):
+
+    def elem_hasattrs(self, elem, attrs):
+        return all(attr in elem.attrib for attr in attrs)
+
+    def test_debug_info(self):
+        try:
+            assert os.path.exists(self.debug_dest)
+
+            t = DebugWriter.etree.parse(self.debug_dest)
+            # the xpath of the standard ElementTree is primitive, don't use
+            # anything fancy
+            L = list(t.find('/Module/Globals'))
+            assert L
+            xml_globals = dict((e.attrib['name'], e.attrib['type']) for e in L)
+            self.assertEqual(len(L), len(xml_globals))
+
+            L = list(t.find('/Module/Functions'))
+            assert L
+            xml_funcs = dict((e.attrib['qualified_name'], e) for e in L)
+            self.assertEqual(len(L), len(xml_funcs))
+
+            # test globals
+            self.assertEqual('CObject', xml_globals.get('c_var'))
+            self.assertEqual('PythonObject', xml_globals.get('python_var'))
+
+            # test functions
+            funcnames = ('codefile.spam', 'codefile.ham', 'codefile.eggs',
+                         'codefile.closure', 'codefile.inner')
+            required_xml_attrs = 'name', 'cname', 'qualified_name'
+            assert all(f in xml_funcs for f in funcnames)
+            spam, ham, eggs = [xml_funcs[funcname] for funcname in funcnames]
+
+            self.assertEqual(spam.attrib['name'], 'spam')
+            self.assertNotEqual('spam', spam.attrib['cname'])
+            assert self.elem_hasattrs(spam, required_xml_attrs)
+
+            # test locals of functions
+            spam_locals = list(spam.find('Locals'))
+            assert spam_locals
+            spam_locals.sort(key=lambda e: e.attrib['name'])
+            names = [e.attrib['name'] for e in spam_locals]
+            self.assertEqual(list('abcd'), names)
+            assert self.elem_hasattrs(spam_locals[0], required_xml_attrs)
+
+            # test arguments of functions
+            spam_arguments = list(spam.find('Arguments'))
+            assert spam_arguments
+            self.assertEqual(1, len(list(spam_arguments)))
+
+            # test step-into functions
+            step_into = spam.find('StepIntoFunctions')
+            spam_stepinto = [x.attrib['name'] for x in step_into]
+            assert spam_stepinto
+            self.assertEqual(2, len(spam_stepinto))
+            assert 'puts' in spam_stepinto
+            assert 'some_c_function' in spam_stepinto
+        except:
+            f = open(self.debug_dest)
+            try:
+                print(f.read())
+            finally:
+                f.close()
+            raise
+
+
+class TestAnalyseDeclarationsTransform(unittest.TestCase):
+    def test_calculate_pickle_checksums(self):
+        checksums = _calculate_pickle_checksums(['member1', 'member2', 'member3'])
+        assert 2 <= len(checksums) <= 3, checksums  # expecting ['0xc0af380' (MD5), '0x0c75bd4', '0xa7a7b94']
+
+
+if __name__ == "__main__":
+    import unittest
+    unittest.main()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestScanning.py

@@ -0,0 +1,136 @@
+from __future__ import unicode_literals
+
+import unittest
+from io import StringIO
+import string
+
+from .. import Scanning
+from ..Symtab import ModuleScope
+from ..TreeFragment import StringParseContext
+from ..Errors import init_thread
+
+# generate some fake code - just a bunch of lines of the form "a0 a1 ..."
+code = []
+for ch in string.ascii_lowercase:
+    line = " ".join(["%s%s" % (ch, n) for n in range(10)])
+    code.append(line)
+code = "\n".join(code)
+
+init_thread()
+
+
+class TestScanning(unittest.TestCase):
+    def make_scanner(self):
+        source = Scanning.StringSourceDescriptor("fake code", code)
+        buf = StringIO(code)
+        context = StringParseContext("fake context")
+        scope = ModuleScope("fake_module", None, None)
+
+        return Scanning.PyrexScanner(buf, source, scope=scope, context=context)
+
+    def test_put_back_positions(self):
+        scanner = self.make_scanner()
+
+        self.assertEqual(scanner.sy, "IDENT")
+        self.assertEqual(scanner.systring, "a0")
+        scanner.next()
+        self.assertEqual(scanner.sy, "IDENT")
+        self.assertEqual(scanner.systring, "a1")
+        a1pos = scanner.position()
+        self.assertEqual(a1pos[1:], (1, 3))
+        a2peek = scanner.peek()  # shouldn't mess up the position
+        self.assertEqual(a1pos, scanner.position())
+        scanner.next()
+        self.assertEqual(a2peek, (scanner.sy, scanner.systring))
+
+        # find next line
+        while scanner.sy != "NEWLINE":
+            scanner.next()
+
+        line_sy = []
+        line_systring = []
+        line_pos = []
+
+        scanner.next()
+        while scanner.sy != "NEWLINE":
+            line_sy.append(scanner.sy)
+            line_systring.append(scanner.systring)
+            line_pos.append(scanner.position())
+            scanner.next()
+
+        for sy, systring, pos in zip(
+            line_sy[::-1], line_systring[::-1], line_pos[::-1]
+        ):
+            scanner.put_back(sy, systring, pos)
+
+        n = 0
+        while scanner.sy != "NEWLINE":
+            self.assertEqual(scanner.sy, line_sy[n])
+            self.assertEqual(scanner.systring, line_systring[n])
+            self.assertEqual(scanner.position(), line_pos[n])
+            scanner.next()
+            n += 1
+
+        self.assertEqual(n, len(line_pos))
+
+    def test_tentatively_scan(self):
+        scanner = self.make_scanner()
+        with Scanning.tentatively_scan(scanner) as errors:
+            while scanner.sy != "NEWLINE":
+                scanner.next()
+        self.assertFalse(errors)
+
+        scanner.next()
+        self.assertEqual(scanner.systring, "b0")
+        pos = scanner.position()
+        with Scanning.tentatively_scan(scanner) as errors:
+            while scanner.sy != "NEWLINE":
+                scanner.next()
+                if scanner.systring == "b7":
+                    scanner.error("Oh no not b7!")
+                    break
+        self.assertTrue(errors)
+        self.assertEqual(scanner.systring, "b0")  # state has been restored
+        self.assertEqual(scanner.position(), pos)
+        scanner.next()
+        self.assertEqual(scanner.systring, "b1")  # and we can keep going again
+        scanner.next()
+        self.assertEqual(scanner.systring, "b2")  # and we can keep going again
+
+        with Scanning.tentatively_scan(scanner) as error:
+            scanner.error("Something has gone wrong with the current symbol")
+        self.assertEqual(scanner.systring, "b2")
+        scanner.next()
+        self.assertEqual(scanner.systring, "b3")
+
+        # test a few combinations of nested scanning
+        sy1, systring1 = scanner.sy, scanner.systring
+        pos1 = scanner.position()
+        with Scanning.tentatively_scan(scanner):
+            scanner.next()
+            sy2, systring2 = scanner.sy, scanner.systring
+            pos2 = scanner.position()
+            with Scanning.tentatively_scan(scanner):
+                with Scanning.tentatively_scan(scanner):
+                    scanner.next()
+                    scanner.next()
+                    scanner.error("Ooops")
+                self.assertEqual((scanner.sy, scanner.systring), (sy2, systring2))
+            self.assertEqual((scanner.sy, scanner.systring), (sy2, systring2))
+            scanner.error("eee")
+        self.assertEqual((scanner.sy, scanner.systring), (sy1, systring1))
+        with Scanning.tentatively_scan(scanner):
+            scanner.next()
+            scanner.next()
+            with Scanning.tentatively_scan(scanner):
+                scanner.next()
+                # no error - but this block should be unwound by the outer block too
+            scanner.next()
+            scanner.error("Oooops")
+        self.assertEqual((scanner.sy, scanner.systring), (sy1, systring1))
+
+
+
+
+if __name__ == "__main__":
+    unittest.main()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestSignatureMatching.py

@@ -0,0 +1,73 @@
+import unittest
+
+from Cython.Compiler import PyrexTypes as pt
+from Cython.Compiler.ExprNodes import NameNode
+from Cython.Compiler.PyrexTypes import CFuncTypeArg
+
+def cfunctype(*arg_types):
+    return pt.CFuncType(pt.c_int_type,
+        [ CFuncTypeArg("name", arg_type, None) for arg_type in arg_types ])
+
+def cppclasstype(name, base_classes):
+    return pt.CppClassType(name, None, 'CPP_'+name, base_classes)
+
+class SignatureMatcherTest(unittest.TestCase):
+    """
+    Test the signature matching algorithm for overloaded signatures.
+    """
+    def assertMatches(self, expected_type, arg_types, functions):
+        match = pt.best_match(arg_types, functions)
+        if expected_type is not None:
+            self.assertNotEqual(None, match)
+        self.assertEqual(expected_type, match.type)
+
+    def test_cpp_reference_single_arg(self):
+        function_types = [
+            cfunctype(pt.CReferenceType(pt.c_int_type)),
+            cfunctype(pt.CReferenceType(pt.c_long_type)),
+            cfunctype(pt.CReferenceType(pt.c_double_type)),
+            ]
+
+        functions = [ NameNode(None, type=t) for t in function_types ]
+        self.assertMatches(function_types[0], [pt.c_int_type], functions)
+        self.assertMatches(function_types[1], [pt.c_long_type], functions)
+        self.assertMatches(function_types[2], [pt.c_double_type], functions)
+
+    def test_cpp_reference_two_args(self):
+        function_types = [
+            cfunctype(
+                pt.CReferenceType(pt.c_int_type), pt.CReferenceType(pt.c_long_type)),
+            cfunctype(
+                pt.CReferenceType(pt.c_long_type), pt.CReferenceType(pt.c_long_type)),
+            ]
+
+        functions = [ NameNode(None, type=t) for t in function_types ]
+        self.assertMatches(function_types[0], [pt.c_int_type, pt.c_long_type], functions)
+        self.assertMatches(function_types[1], [pt.c_long_type, pt.c_long_type], functions)
+        self.assertMatches(function_types[1], [pt.c_long_type, pt.c_int_type], functions)
+
+    def test_cpp_reference_cpp_class(self):
+        classes = [ cppclasstype("Test%d" % i, []) for i in range(2) ]
+        function_types = [
+            cfunctype(pt.CReferenceType(classes[0])),
+            cfunctype(pt.CReferenceType(classes[1])),
+            ]
+
+        functions = [ NameNode(None, type=t) for t in function_types ]
+        self.assertMatches(function_types[0], [classes[0]], functions)
+        self.assertMatches(function_types[1], [classes[1]], functions)
+
+    def test_cpp_reference_cpp_class_and_int(self):
+        classes = [ cppclasstype("Test%d" % i, []) for i in range(2) ]
+        function_types = [
+            cfunctype(pt.CReferenceType(classes[0]), pt.c_int_type),
+            cfunctype(pt.CReferenceType(classes[0]), pt.c_long_type),
+            cfunctype(pt.CReferenceType(classes[1]), pt.c_int_type),
+            cfunctype(pt.CReferenceType(classes[1]), pt.c_long_type),
+            ]
+
+        functions = [ NameNode(None, type=t) for t in function_types ]
+        self.assertMatches(function_types[0], [classes[0], pt.c_int_type], functions)
+        self.assertMatches(function_types[1], [classes[0], pt.c_long_type], functions)
+        self.assertMatches(function_types[2], [classes[1], pt.c_int_type], functions)
+        self.assertMatches(function_types[3], [classes[1], pt.c_long_type], functions)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestStringEncoding.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+import sys
+import unittest
+
+import Cython.Compiler.StringEncoding as StringEncoding
+
+
+class StringEncodingTest(unittest.TestCase):
+    """
+    Test the StringEncoding module.
+    """
+    def test_string_contains_lone_surrogates(self):
+        self.assertFalse(StringEncoding.string_contains_lone_surrogates(u"abc"))
+        self.assertFalse(StringEncoding.string_contains_lone_surrogates(u"\uABCD"))
+        self.assertFalse(StringEncoding.string_contains_lone_surrogates(u"\N{SNOWMAN}"))
+
+        # This behaves differently in Py2 when freshly parsed and read from a .pyc file,
+        # but it seems to be a marshalling bug in Py2, which doesn't hurt us in Cython.
+        if sys.version_info[0] != 2:
+            self.assertTrue(StringEncoding.string_contains_lone_surrogates(u"\uD800\uDFFF"))
+
+        # In Py2 with 16bit Unicode, the following is indistinguishable from the 32bit character.
+        obfuscated_surrogate_pair = (u"\uDFFF" + "\uD800")[::-1]
+        if sys.version_info[0] == 2 and sys.maxunicode == 65565:
+            self.assertFalse(StringEncoding.string_contains_lone_surrogates(obfuscated_surrogate_pair))
+        else:
+            self.assertTrue(StringEncoding.string_contains_lone_surrogates(obfuscated_surrogate_pair))
+
+        self.assertTrue(StringEncoding.string_contains_lone_surrogates(u"\uD800"))
+        self.assertTrue(StringEncoding.string_contains_lone_surrogates(u"\uDFFF"))
+        self.assertTrue(StringEncoding.string_contains_lone_surrogates(u"\uDFFF\uD800"))
+        self.assertTrue(StringEncoding.string_contains_lone_surrogates(u"\uD800x\uDFFF"))
+
+    def test_string_contains_surrogates(self):
+        self.assertFalse(StringEncoding.string_contains_surrogates(u"abc"))
+        self.assertFalse(StringEncoding.string_contains_surrogates(u"\uABCD"))
+        self.assertFalse(StringEncoding.string_contains_surrogates(u"\N{SNOWMAN}"))
+
+        self.assertTrue(StringEncoding.string_contains_surrogates(u"\uD800"))
+        self.assertTrue(StringEncoding.string_contains_surrogates(u"\uDFFF"))
+        self.assertTrue(StringEncoding.string_contains_surrogates(u"\uD800\uDFFF"))
+        self.assertTrue(StringEncoding.string_contains_surrogates(u"\uDFFF\uD800"))
+        self.assertTrue(StringEncoding.string_contains_surrogates(u"\uD800x\uDFFF"))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestTreeFragment.py

@@ -0,0 +1,63 @@
+from Cython.TestUtils import CythonTest
+from Cython.Compiler.TreeFragment import *
+from Cython.Compiler.Nodes import *
+from Cython.Compiler.UtilNodes import *
+
+class TestTreeFragments(CythonTest):
+
+    def test_basic(self):
+        F = self.fragment(u"x = 4")
+        T = F.copy()
+        self.assertCode(u"x = 4", T)
+
+    def test_copy_is_taken(self):
+        F = self.fragment(u"if True: x = 4")
+        T1 = F.root
+        T2 = F.copy()
+        self.assertEqual("x", T2.stats[0].if_clauses[0].body.lhs.name)
+        T2.stats[0].if_clauses[0].body.lhs.name = "other"
+        self.assertEqual("x", T1.stats[0].if_clauses[0].body.lhs.name)
+
+    def test_substitutions_are_copied(self):
+        T = self.fragment(u"y + y").substitute({"y": NameNode(pos=None, name="x")})
+        self.assertEqual("x", T.stats[0].expr.operand1.name)
+        self.assertEqual("x", T.stats[0].expr.operand2.name)
+        self.assertTrue(T.stats[0].expr.operand1 is not T.stats[0].expr.operand2)
+
+    def test_substitution(self):
+        F = self.fragment(u"x = 4")
+        y = NameNode(pos=None, name=u"y")
+        T = F.substitute({"x" : y})
+        self.assertCode(u"y = 4", T)
+
+    def test_exprstat(self):
+        F = self.fragment(u"PASS")
+        pass_stat = PassStatNode(pos=None)
+        T = F.substitute({"PASS" : pass_stat})
+        self.assertTrue(isinstance(T.stats[0], PassStatNode), T)
+
+    def test_pos_is_transferred(self):
+        F = self.fragment(u"""
+        x = y
+        x = u * v ** w
+        """)
+        T = F.substitute({"v" : NameNode(pos=None, name="a")})
+        v = F.root.stats[1].rhs.operand2.operand1
+        a = T.stats[1].rhs.operand2.operand1
+        self.assertEqual(v.pos, a.pos)
+
+    def test_temps(self):
+        TemplateTransform.temp_name_counter = 0
+        F = self.fragment(u"""
+            TMP
+            x = TMP
+        """)
+        T = F.substitute(temps=[u"TMP"])
+        s = T.body.stats
+        self.assertTrue(isinstance(s[0].expr, TempRefNode))
+        self.assertTrue(isinstance(s[1].rhs, TempRefNode))
+        self.assertTrue(s[0].expr.handle is s[1].rhs.handle)
+
+if __name__ == "__main__":
+    import unittest
+    unittest.main()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/TestTreePath.py

@@ -0,0 +1,93 @@
+import unittest
+from Cython.TestUtils import TransformTest
+from Cython.Compiler.TreePath import find_first, find_all
+from Cython.Compiler import Nodes, ExprNodes
+
+class TestTreePath(TransformTest):
+    _tree = None
+
+    def _build_tree(self):
+        if self._tree is None:
+            self._tree = self.run_pipeline([], u"""
+            def decorator(fun):  # DefNode
+                return fun       # ReturnStatNode, NameNode
+            @decorator           # NameNode
+            def decorated():     # DefNode
+                pass
+            """)
+        return self._tree
+
+    def test_node_path(self):
+        t = self._build_tree()
+        self.assertEqual(2, len(find_all(t, "//DefNode")))
+        self.assertEqual(2, len(find_all(t, "//NameNode")))
+        self.assertEqual(1, len(find_all(t, "//ReturnStatNode")))
+        self.assertEqual(1, len(find_all(t, "//DefNode//ReturnStatNode")))
+
+    def test_node_path_star(self):
+        t = self._build_tree()
+        self.assertEqual(10, len(find_all(t, "//*")))
+        self.assertEqual(8, len(find_all(t, "//DefNode//*")))
+        self.assertEqual(0, len(find_all(t, "//NameNode//*")))
+
+    def test_node_path_attribute(self):
+        t = self._build_tree()
+        self.assertEqual(2, len(find_all(t, "//NameNode/@name")))
+        self.assertEqual(['fun', 'decorator'], find_all(t, "//NameNode/@name"))
+
+    def test_node_path_attribute_dotted(self):
+        t = self._build_tree()
+        self.assertEqual(1, len(find_all(t, "//ReturnStatNode/@value.name")))
+        self.assertEqual(['fun'], find_all(t, "//ReturnStatNode/@value.name"))
+
+    def test_node_path_child(self):
+        t = self._build_tree()
+        self.assertEqual(1, len(find_all(t, "//DefNode/ReturnStatNode/NameNode")))
+        self.assertEqual(1, len(find_all(t, "//ReturnStatNode/NameNode")))
+
+    def test_node_path_node_predicate(self):
+        t = self._build_tree()
+        self.assertEqual(0, len(find_all(t, "//DefNode[.//ForInStatNode]")))
+        self.assertEqual(2, len(find_all(t, "//DefNode[.//NameNode]")))
+        self.assertEqual(1, len(find_all(t, "//ReturnStatNode[./NameNode]")))
+        self.assertEqual(Nodes.ReturnStatNode,
+                         type(find_first(t, "//ReturnStatNode[./NameNode]")))
+
+    def test_node_path_node_predicate_step(self):
+        t = self._build_tree()
+        self.assertEqual(2, len(find_all(t, "//DefNode[.//NameNode]")))
+        self.assertEqual(8, len(find_all(t, "//DefNode[.//NameNode]//*")))
+        self.assertEqual(1, len(find_all(t, "//DefNode[.//NameNode]//ReturnStatNode")))
+        self.assertEqual(Nodes.ReturnStatNode,
+                         type(find_first(t, "//DefNode[.//NameNode]//ReturnStatNode")))
+
+    def test_node_path_attribute_exists(self):
+        t = self._build_tree()
+        self.assertEqual(2, len(find_all(t, "//NameNode[@name]")))
+        self.assertEqual(ExprNodes.NameNode,
+                         type(find_first(t, "//NameNode[@name]")))
+
+    def test_node_path_attribute_exists_not(self):
+        t = self._build_tree()
+        self.assertEqual(0, len(find_all(t, "//NameNode[not(@name)]")))
+        self.assertEqual(2, len(find_all(t, "//NameNode[not(@honking)]")))
+
+    def test_node_path_and(self):
+        t = self._build_tree()
+        self.assertEqual(1, len(find_all(t, "//DefNode[.//ReturnStatNode and .//NameNode]")))
+        self.assertEqual(0, len(find_all(t, "//NameNode[@honking and @name]")))
+        self.assertEqual(0, len(find_all(t, "//NameNode[@name and @honking]")))
+        self.assertEqual(2, len(find_all(t, "//DefNode[.//NameNode[@name] and @name]")))
+
+    def test_node_path_attribute_string_predicate(self):
+        t = self._build_tree()
+        self.assertEqual(1, len(find_all(t, "//NameNode[@name = 'decorator']")))
+
+    def test_node_path_recursive_predicate(self):
+        t = self._build_tree()
+        self.assertEqual(2, len(find_all(t, "//DefNode[.//NameNode[@name]]")))
+        self.assertEqual(1, len(find_all(t, "//DefNode[.//NameNode[@name = 'decorator']]")))
+        self.assertEqual(1, len(find_all(t, "//DefNode[.//ReturnStatNode[./NameNode[@name = 'fun']]/NameNode]")))
+
+if __name__ == '__main__':
+    unittest.main()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/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])

tuning-competition-baseline/.venv/lib/python3.11/site-packages/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, u"""
+                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'])

tuning-competition-baseline/.venv/lib/python3.11/site-packages/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 ""

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/Tests/__init__.py

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