Cython 3.1.3__cp314-cp314-win_amd64.whl

Cython/Build/BuildExecutable.py

@@ -0,0 +1,169 @@
+"""
+Compile a Python script into an executable that embeds CPython.
+Requires CPython to be built as a shared library ('libpythonX.Y').
+
+Basic usage:
+
+    python -m Cython.Build.BuildExecutable [ARGS] somefile.py
+"""
+
+
+DEBUG = True
+
+import sys
+import os
+if sys.version_info < (3, 9):
+    from distutils import sysconfig as _sysconfig
+
+    class sysconfig:
+
+        @staticmethod
+        def get_path(name):
+            assert name == 'include'
+            return _sysconfig.get_python_inc()
+
+        get_config_var = staticmethod(_sysconfig.get_config_var)
+else:
+    # sysconfig can be trusted from cpython >= 3.8.7
+    import sysconfig
+
+
+def get_config_var(name, default=''):
+    return sysconfig.get_config_var(name) or default
+
+INCDIR = sysconfig.get_path('include')
+LIBDIR1 = get_config_var('LIBDIR')
+LIBDIR2 = get_config_var('LIBPL')
+PYLIB = get_config_var('LIBRARY')
+PYLIB_DYN = get_config_var('LDLIBRARY')
+if PYLIB_DYN == PYLIB:
+    # no shared library
+    PYLIB_DYN = ''
+else:
+    PYLIB_DYN = os.path.splitext(PYLIB_DYN[3:])[0]  # 'lib(XYZ).so' -> XYZ
+
+CC = get_config_var('CC', os.environ.get('CC', ''))
+CFLAGS = get_config_var('CFLAGS') + ' ' + os.environ.get('CFLAGS', '')
+LINKCC = get_config_var('LINKCC', os.environ.get('LINKCC', CC))
+LINKFORSHARED = get_config_var('LINKFORSHARED')
+LIBS = get_config_var('LIBS')
+SYSLIBS = get_config_var('SYSLIBS')
+EXE_EXT = sysconfig.get_config_var('EXE')
+
+
+def _debug(msg, *args):
+    if DEBUG:
+        if args:
+            msg = msg % args
+        sys.stderr.write(msg + '\n')
+
+
+def dump_config():
+    _debug('INCDIR: %s', INCDIR)
+    _debug('LIBDIR1: %s', LIBDIR1)
+    _debug('LIBDIR2: %s', LIBDIR2)
+    _debug('PYLIB: %s', PYLIB)
+    _debug('PYLIB_DYN: %s', PYLIB_DYN)
+    _debug('CC: %s', CC)
+    _debug('CFLAGS: %s', CFLAGS)
+    _debug('LINKCC: %s', LINKCC)
+    _debug('LINKFORSHARED: %s', LINKFORSHARED)
+    _debug('LIBS: %s', LIBS)
+    _debug('SYSLIBS: %s', SYSLIBS)
+    _debug('EXE_EXT: %s', EXE_EXT)
+
+
+def _parse_args(args):
+    cy_args = []
+    last_arg = None
+    for i, arg in enumerate(args):
+        if arg.startswith('-'):
+            cy_args.append(arg)
+        elif last_arg in ('-X', '--directive'):
+            cy_args.append(arg)
+        else:
+            input_file = arg
+            args = args[i+1:]
+            break
+        last_arg = arg
+    else:
+        raise ValueError('no input file provided')
+
+    return input_file, cy_args, args
+
+
+def runcmd(cmd, shell=True):
+    if shell:
+        cmd = ' '.join(cmd)
+        _debug(cmd)
+    else:
+        _debug(' '.join(cmd))
+
+    import subprocess
+    returncode = subprocess.call(cmd, shell=shell)
+
+    if returncode:
+        sys.exit(returncode)
+
+
+def clink(basename):
+    runcmd([LINKCC, '-o', basename + EXE_EXT, basename+'.o', '-L'+LIBDIR1, '-L'+LIBDIR2]
+           + [PYLIB_DYN and ('-l'+PYLIB_DYN) or os.path.join(LIBDIR1, PYLIB)]
+           + LIBS.split() + SYSLIBS.split() + LINKFORSHARED.split())
+
+
+def ccompile(basename):
+    runcmd([CC, '-c', '-o', basename+'.o', basename+'.c', '-I' + INCDIR] + CFLAGS.split())
+
+
+def cycompile(input_file, options=()):
+    from ..Compiler import Version, CmdLine, Main
+    options, sources = CmdLine.parse_command_line(list(options or ()) + ['--embed', input_file])
+    _debug('Using Cython %s to compile %s', Version.version, input_file)
+    result = Main.compile(sources, options)
+    if result.num_errors > 0:
+        sys.exit(1)
+
+
+def exec_file(program_name, args=()):
+    runcmd([os.path.abspath(program_name)] + list(args), shell=False)
+
+
+def build(input_file, compiler_args=(), force=False):
+    """
+    Build an executable program from a Cython module.
+
+    Returns the name of the executable file.
+    """
+    basename = os.path.splitext(input_file)[0]
+    exe_file = basename + EXE_EXT
+    if not force and os.path.abspath(exe_file) == os.path.abspath(input_file):
+        raise ValueError("Input and output file names are the same, refusing to overwrite")
+    if (not force and os.path.exists(exe_file) and os.path.exists(input_file)
+            and os.path.getmtime(input_file) <= os.path.getmtime(exe_file)):
+        _debug("File is up to date, not regenerating %s", exe_file)
+        return exe_file
+    cycompile(input_file, compiler_args)
+    ccompile(basename)
+    clink(basename)
+    return exe_file
+
+
+def build_and_run(args):
+    """
+    Build an executable program from a Cython module and run it.
+
+    Arguments after the module name will be passed verbatimly to the program.
+    """
+    program_name, args = _build(args)
+    exec_file(program_name, args)
+
+
+def _build(args):
+    input_file, cy_args, args = _parse_args(args)
+    program_name = build(input_file, cy_args)
+    return program_name, args
+
+
+if __name__ == '__main__':
+    _build(sys.argv[1:])

Cython/Build/Cache.py

@@ -0,0 +1,199 @@
+from dataclasses import dataclass
+import sys
+import os
+import hashlib
+import shutil
+import subprocess
+from ..Utils import safe_makedirs, cached_function
+import zipfile
+from .. import __version__
+
+try:
+    import zlib
+
+    zipfile_compression_mode = zipfile.ZIP_DEFLATED
+except ImportError:
+    zipfile_compression_mode = zipfile.ZIP_STORED
+
+try:
+    import gzip
+
+    gzip_open = gzip.open
+    gzip_ext = ".gz"
+except ImportError:
+    gzip_open = open
+    gzip_ext = ""
+
+zip_ext = ".zip"
+
+MAX_CACHE_SIZE = 1024 * 1024 * 100
+
+join_path = cached_function(os.path.join)
+
+
+@cached_function
+def file_hash(filename):
+    path = os.path.normpath(filename)
+    prefix = ("%d:%s" % (len(path), path)).encode("UTF-8")
+    m = hashlib.sha256(prefix)
+    with open(path, "rb") as f:
+        data = f.read(65000)
+        while data:
+            m.update(data)
+            data = f.read(65000)
+    return m.hexdigest()
+
+
+@cached_function
+def get_cython_cache_dir():
+    r"""
+    Return the base directory containing Cython's caches.
+
+    Priority:
+
+    1. CYTHON_CACHE_DIR
+    2. (OS X): ~/Library/Caches/Cython
+       (posix not OS X): XDG_CACHE_HOME/cython if XDG_CACHE_HOME defined
+    3. ~/.cython
+
+    """
+    if "CYTHON_CACHE_DIR" in os.environ:
+        return os.environ["CYTHON_CACHE_DIR"]
+
+    parent = None
+    if os.name == "posix":
+        if sys.platform == "darwin":
+            parent = os.path.expanduser("~/Library/Caches")
+        else:
+            # this could fallback on ~/.cache
+            parent = os.environ.get("XDG_CACHE_HOME")
+
+    if parent and os.path.isdir(parent):
+        return join_path(parent, "cython")
+
+    # last fallback: ~/.cython
+    return os.path.expanduser(join_path("~", ".cython"))
+
+
+@dataclass
+class FingerprintFlags:
+    language: str = "c"
+    py_limited_api: bool = False
+    np_pythran: bool = False
+
+    def get_fingerprint(self):
+        return str((self.language, self.py_limited_api, self.np_pythran))
+
+
+class Cache:
+    def __init__(self, path, cache_size=None):
+        if path is None:
+            self.path = join_path(get_cython_cache_dir(), "compiler")
+        else:
+            self.path = path
+        self.cache_size = cache_size if cache_size is not None else MAX_CACHE_SIZE
+        if not os.path.exists(self.path):
+            os.makedirs(self.path)
+
+    def transitive_fingerprint(
+        self, filename, dependencies, compilation_options, flags=FingerprintFlags()
+    ):
+        r"""
+        Return a fingerprint of a cython file that is about to be cythonized.
+
+        Fingerprints are looked up in future compilations. If the fingerprint
+        is found, the cythonization can be skipped. The fingerprint must
+        incorporate everything that has an influence on the generated code.
+        """
+        try:
+            m = hashlib.sha256(__version__.encode("UTF-8"))
+            m.update(file_hash(filename).encode("UTF-8"))
+            for x in sorted(dependencies):
+                if os.path.splitext(x)[1] not in (".c", ".cpp", ".h"):
+                    m.update(file_hash(x).encode("UTF-8"))
+            # Include the module attributes that change the compilation result
+            # in the fingerprint. We do not iterate over module.__dict__ and
+            # include almost everything here as users might extend Extension
+            # with arbitrary (random) attributes that would lead to cache
+            # misses.
+            m.update(flags.get_fingerprint().encode("UTF-8"))
+            m.update(compilation_options.get_fingerprint().encode("UTF-8"))
+            return m.hexdigest()
+        except OSError:
+            return None
+
+    def fingerprint_file(self, cfile, fingerprint, ext):
+        return (
+            join_path(self.path, "%s-%s" % (os.path.basename(cfile), fingerprint)) + ext
+        )
+
+    def lookup_cache(self, c_file, fingerprint):
+        # Cython-generated c files are highly compressible.
+        # (E.g. a compression ratio of about 10 for Sage).
+        if not os.path.exists(self.path):
+            safe_makedirs(self.path)
+        gz_fingerprint_file = self.fingerprint_file(c_file, fingerprint, gzip_ext)
+        if os.path.exists(gz_fingerprint_file):
+            return gz_fingerprint_file
+        zip_fingerprint_file = self.fingerprint_file(c_file, fingerprint, zip_ext)
+        if os.path.exists(zip_fingerprint_file):
+            return zip_fingerprint_file
+        return None
+
+    def load_from_cache(self, c_file, cached):
+        ext = os.path.splitext(cached)[1]
+        if ext == gzip_ext:
+            os.utime(cached, None)
+            with gzip_open(cached, "rb") as g:
+                with open(c_file, "wb") as f:
+                    shutil.copyfileobj(g, f)
+        elif ext == zip_ext:
+            os.utime(cached, None)
+            dirname = os.path.dirname(c_file)
+            with zipfile.ZipFile(cached) as z:
+                for artifact in z.namelist():
+                    z.extract(artifact, join_path(dirname, artifact))
+        else:
+            raise ValueError(f"Unsupported cache file extension: {ext}")
+
+    def store_to_cache(self, c_file, fingerprint, compilation_result):
+        artifacts = compilation_result.get_generated_source_files()
+        if len(artifacts) == 1:
+            fingerprint_file = self.fingerprint_file(c_file, fingerprint, gzip_ext)
+            with open(c_file, "rb") as f:
+                with gzip_open(fingerprint_file + ".tmp", "wb") as g:
+                    shutil.copyfileobj(f, g)
+        else:
+            fingerprint_file = self.fingerprint_file(c_file, fingerprint, zip_ext)
+            with zipfile.ZipFile(
+                fingerprint_file + ".tmp", "w", zipfile_compression_mode
+            ) as zip:
+                for artifact in artifacts:
+                    zip.write(artifact, os.path.basename(artifact))
+        os.rename(fingerprint_file + ".tmp", fingerprint_file)
+
+    def cleanup_cache(self, ratio=0.85):
+        try:
+            completed_process = subprocess.run(
+                ["du", "-s", "-k", os.path.abspath(self.path)], stdout=subprocess.PIPE
+            )
+            stdout = completed_process.stdout
+            if completed_process.returncode == 0:
+                total_size = 1024 * int(stdout.strip().split()[0])
+                if total_size < self.cache_size:
+                    return
+        except (OSError, ValueError):
+            pass
+        total_size = 0
+        all = []
+        for file in os.listdir(self.path):
+            path = join_path(self.path, file)
+            s = os.stat(path)
+            total_size += s.st_size
+            all.append((s.st_atime, s.st_size, path))
+        if total_size > self.cache_size:
+            for time, size, file in reversed(sorted(all)):
+                os.unlink(file)
+                total_size -= size
+                if total_size < self.cache_size * ratio:
+                    break

Cython/Build/Cythonize.py

@@ -0,0 +1,323 @@
+import os
+import shutil
+import tempfile
+from collections import defaultdict
+
+from .Dependencies import cythonize, extended_iglob
+from ..Utils import is_package_dir
+from ..Compiler import Options
+
+try:
+    import multiprocessing
+    parallel_compiles = int(multiprocessing.cpu_count() * 1.5)
+except ImportError:
+    multiprocessing = None
+    parallel_compiles = 0
+
+
+class _FakePool:
+    def map_async(self, func, args):
+        for _ in map(func, args):
+            pass
+
+    def close(self):
+        pass
+
+    def terminate(self):
+        pass
+
+    def join(self):
+        pass
+
+
+def find_package_base(path):
+    base_dir, package_path = os.path.split(path)
+    while is_package_dir(base_dir):
+        base_dir, parent = os.path.split(base_dir)
+        package_path = '%s/%s' % (parent, package_path)
+    return base_dir, package_path
+
+
+def cython_compile(path_pattern, options) -> dict:
+    all_paths = map(os.path.abspath, extended_iglob(path_pattern))
+    ext_modules_by_basedir = _cython_compile_files(all_paths, options)
+    _build(list(ext_modules_by_basedir.items()), options.parallel)
+
+
+def _cython_compile_files(all_paths, options) -> dict:
+    ext_modules_to_build = defaultdict(list)
+
+    for path in all_paths:
+        if options.build_inplace:
+            base_dir = path
+            while not os.path.isdir(base_dir) or is_package_dir(base_dir):
+                base_dir = os.path.dirname(base_dir)
+        else:
+            base_dir = None
+
+        if os.path.isdir(path):
+            # recursively compiling a package
+            paths = [os.path.join(path, '**', '*.{py,pyx}')]
+        else:
+            # assume it's a file(-like thing)
+            paths = [path]
+
+        ext_modules = cythonize(
+            paths,
+            nthreads=options.parallel,
+            exclude_failures=options.keep_going,
+            exclude=options.excludes,
+            compiler_directives=options.directives,
+            compile_time_env=options.compile_time_env,
+            force=options.force,
+            quiet=options.quiet,
+            depfile=options.depfile,
+            language=options.language,
+            **options.options)
+
+        if ext_modules and options.build:
+            ext_modules_to_build[base_dir].extend(ext_modules)
+
+    return dict(ext_modules_to_build)
+
+
+def _build(ext_modules, parallel):
+    modcount = sum(len(modules) for _, modules in ext_modules)
+    if not modcount:
+        return
+    if modcount == 1 or parallel < 2:
+        run_distutils(ext_modules[0])
+        return
+
+    try:
+        pool = multiprocessing.Pool(parallel)
+    except OSError:
+        pool = _FakePool()
+    try:
+        pool.map_async(run_distutils, [
+            (base_dir, [ext]) for base_dir, modules in ext_modules for ext in modules])
+    except:
+        pool.terminate()
+        raise
+    else:
+        pool.close()
+        pool.join()
+
+
+def run_distutils(args):
+    try:
+        from distutils.core import setup
+    except ImportError:
+        try:
+            from setuptools import setup
+        except ImportError:
+            raise ImportError("'distutils' is not available. Please install 'setuptools' for binary builds.")
+
+    base_dir, ext_modules = args
+    script_args = ['build_ext', '-i']
+    cwd = os.getcwd()
+    temp_dir = None
+    try:
+        if base_dir:
+            os.chdir(base_dir)
+            temp_dir = tempfile.mkdtemp(dir=base_dir)
+            script_args.extend(['--build-temp', temp_dir])
+        setup(
+            script_name='setup.py',
+            script_args=script_args,
+            ext_modules=ext_modules,
+        )
+    finally:
+        if base_dir:
+            os.chdir(cwd)
+            if temp_dir and os.path.isdir(temp_dir):
+                shutil.rmtree(temp_dir)
+
+
+def benchmark(code, setup_code=None, import_module=None, directives=None):
+    from Cython.Build.Inline import cymeit
+
+    timings, number = cymeit(code, setup_code, import_module, directives, repeat=9)
+
+    # Based on 'timeit.main()' in CPython 3.13.
+    units = {"nsec": 1e-9, "usec": 1e-6, "msec": 1e-3, "sec": 1.0}
+    scales = [(scale, unit) for unit, scale in reversed(units.items())]  # biggest first
+
+    def format_time(t):
+        for scale, unit in scales:
+            if t >= scale:
+                break
+        else:
+            raise RuntimeError("Timing is below nanoseconds: {t:f}")
+        return f"{t / scale :.3f} {unit}"
+
+    timings.sort()
+    assert len(timings) & 1 == 1  # odd number of timings, for median position
+    fastest, median, slowest = timings[0], timings[len(timings) // 2], timings[-1]
+
+    print(f"{number} loops, best of {len(timings)}: {format_time(fastest)} per loop (median: {format_time(median)})")
+
+    if slowest > fastest * 4:
+        print(
+            "The timings are likely unreliable. "
+            f"The worst time ({format_time(slowest)}) was more than four times "
+            f"slower than the best time ({format_time(fastest)}).")
+
+
+def create_args_parser():
+    from argparse import ArgumentParser, RawDescriptionHelpFormatter
+    from ..Compiler.CmdLine import ParseDirectivesAction, ParseOptionsAction, ParseCompileTimeEnvAction
+
+    parser = ArgumentParser(
+        formatter_class=RawDescriptionHelpFormatter,
+        epilog="""\
+Environment variables:
+  CYTHON_FORCE_REGEN: if set to 1, forces cythonize to regenerate the output files regardless
+        of modification times and changes.
+  CYTHON_CACHE_DIR: the base directory containing Cython's caches.
+  Environment variables accepted by setuptools are supported to configure the C compiler and build:
+  https://setuptools.pypa.io/en/latest/userguide/ext_modules.html#compiler-and-linker-options"""
+    )
+
+    parser.add_argument('-X', '--directive', metavar='NAME=VALUE,...',
+                      dest='directives', default={}, type=str,
+                      action=ParseDirectivesAction,
+                      help='set a compiler directive')
+    parser.add_argument('-E', '--compile-time-env', metavar='NAME=VALUE,...',
+                      dest='compile_time_env', default={}, type=str,
+                      action=ParseCompileTimeEnvAction,
+                      help='set a compile time environment variable')
+    parser.add_argument('-s', '--option', metavar='NAME=VALUE',
+                      dest='options', default={}, type=str,
+                      action=ParseOptionsAction,
+                      help='set a cythonize option')
+    parser.add_argument('-2', dest='language_level', action='store_const', const=2, default=None,
+                      help='use Python 2 syntax mode by default')
+    parser.add_argument('-3', dest='language_level', action='store_const', const=3,
+                      help='use Python 3 syntax mode by default')
+    parser.add_argument('--3str', dest='language_level', action='store_const', const=3,
+                      help='use Python 3 syntax mode by default (deprecated alias for -3)')
+    parser.add_argument('-+', '--cplus', dest='language', action='store_const', const='c++', default=None,
+                        help='Compile as C++ rather than C')
+    parser.add_argument('-a', '--annotate', action='store_const', const='default', dest='annotate',
+                      help='Produce a colorized HTML version of the source.')
+    parser.add_argument('--annotate-fullc', action='store_const', const='fullc', dest='annotate',
+                      help='Produce a colorized HTML version of the source '
+                           'which includes entire generated C/C++-code.')
+    parser.add_argument('-x', '--exclude', metavar='PATTERN', dest='excludes',
+                      action='append', default=[],
+                      help='exclude certain file patterns from the compilation')
+
+    parser.add_argument('-b', '--build', dest='build', action='store_true', default=None,
+                      help='build extension modules using distutils/setuptools')
+    parser.add_argument('-i', '--inplace', dest='build_inplace', action='store_true', default=None,
+                      help='build extension modules in place using distutils/setuptools (implies -b)')
+
+    parser.add_argument('--timeit', dest='benchmark', metavar="CODESTRING", type=str, default=None,
+                      help="build in place, then compile+run CODESTRING as benchmark in first module's namespace (implies -i)")
+    parser.add_argument('--setup', dest='benchmark_setup', metavar="CODESTRING", type=str, default=None,
+                      help="use CODESTRING as pre-benchmark setup code for --bench")
+
+    parser.add_argument('-j', '--parallel', dest='parallel', metavar='N',
+                      type=int, default=parallel_compiles,
+                      help=f'run builds in N parallel jobs (default: {parallel_compiles or 1})')
+    parser.add_argument('-f', '--force', dest='force', action='store_true', default=None,
+                      help='force recompilation')
+    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true', default=None,
+                      help='be less verbose during compilation')
+
+    parser.add_argument('--lenient', dest='lenient', action='store_true', default=None,
+                      help='increase Python compatibility by ignoring some compile time errors')
+    parser.add_argument('-k', '--keep-going', dest='keep_going', action='store_true', default=None,
+                      help='compile as much as possible, ignore compilation failures')
+    parser.add_argument('--no-docstrings', dest='no_docstrings', action='store_true', default=None,
+                      help='strip docstrings')
+    parser.add_argument('-M', '--depfile', action='store_true', help='produce depfiles for the sources')
+    parser.add_argument('sources', nargs='*')
+    return parser
+
+
+def parse_args_raw(parser, args):
+    options, unknown = parser.parse_known_args(args)
+    sources = options.sources
+    # if positional arguments were interspersed
+    # some of them are in unknown
+    for option in unknown:
+        if option.startswith('-'):
+            parser.error("unknown option "+option)
+        else:
+            sources.append(option)
+    del options.sources
+    return (options, sources)
+
+
+def parse_args(args):
+    parser = create_args_parser()
+    options, args = parse_args_raw(parser, args)
+
+    if options.benchmark is not None:
+        options.build_inplace = True
+    elif not args:
+        parser.error("no source files provided")
+
+    if options.build_inplace:
+        options.build = True
+    if multiprocessing is None:
+        options.parallel = 0
+    if options.language_level:
+        assert options.language_level in (2, 3, '3str')
+        options.options['language_level'] = options.language_level
+
+    if options.lenient:
+        # increase Python compatibility by ignoring compile time errors
+        Options.error_on_unknown_names = False
+        Options.error_on_uninitialized = False
+
+    if options.annotate:
+        Options.annotate = options.annotate
+
+    if options.no_docstrings:
+        Options.docstrings = False
+
+    return options, args
+
+
+def main(args=None):
+    options, paths = parse_args(args)
+
+    all_paths = []
+    for path in paths:
+        expanded_path = [os.path.abspath(p) for p in extended_iglob(path)]
+        if not expanded_path:
+            import sys
+            print("{}: No such file or directory: '{}'".format(sys.argv[0], path), file=sys.stderr)
+            sys.exit(1)
+        all_paths.extend(expanded_path)
+
+    ext_modules_by_basedir = _cython_compile_files(all_paths, options)
+
+    if ext_modules_by_basedir and options.build:
+        _build(list(ext_modules_by_basedir.items()), options.parallel)
+
+    if options.benchmark is not None:
+        base_dir = import_module = None
+        if ext_modules_by_basedir:
+            base_dir, first_extensions = ext_modules_by_basedir.popitem()
+            if first_extensions:
+                import_module = first_extensions[0].name
+
+        import sys
+        if base_dir is not None:
+            sys.path.insert(0, base_dir)
+
+        benchmark(
+            options.benchmark, options.benchmark_setup,
+            import_module=import_module,
+        )
+
+        if base_dir is not None:
+            sys.path.remove(base_dir)
+
+
+if __name__ == '__main__':
+    main()